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  * 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 #include "opj_includes.h"
  32
  33 /** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
  34 /*@{*/
  35
  36 /** @name Local static functions */
  37 /*@{*/
  38
  39 /**
  40 Read box headers
  41 @param cinfo Codec context info
  42 @param cio Input stream
  43 @param box
  44 @return Returns true if successful, returns false otherwise
  45 */
  46 static bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box);
  47 /*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
  48 /**
  49 Read the IHDR box - Image Header box
  50 @param jp2 JP2 handle
  51 @param cio Input buffer stream
  52 @return Returns true if successful, returns false otherwise
  53 */
  54 static bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
  55 static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
  56 static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
  57 static bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
  58 static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio);
  59 /**
  60 Write the FTYP box - File type box
  61 @param jp2 JP2 handle
  62 @param cio Output buffer stream
  63 */
  64 static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
  65 /**
  66 Read the FTYP box - File type box
  67 @param jp2 JP2 handle
  68 @param cio Input buffer stream
  69 @return Returns true if successful, returns false otherwise
  70 */
  71 static bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
  72 static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
  73 static bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset);
  74 static void jp2_write_jp(opj_cio_t *cio);
  75 /**
  76 Read the JP box - JPEG 2000 signature
  77 @param jp2 JP2 handle
  78 @param cio Input buffer stream
  79 @return Returns true if successful, returns false otherwise
  80 */
  81 static bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio);
  82 /**
  83 Decode the structure of a JP2 file
  84 @param jp2 JP2 handle
  85 @param cio Input buffer stream
  86 @param color Collector for profile, cdef and pclr data
  87 @return Returns true if successful, returns false otherwise
  88 */
  89 static bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
  90         opj_jp2_color_t *color);
  91 /**
  92 Apply collected palette data
  93 @param color Collector for profile, cdef and pclr data
  94 @param image
  95 */
  96 static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image);
  97 /**
  98 Collect palette data
  99 @param jp2 JP2 handle
 100 @param cio Input buffer stream
 101 @param box
 102 @param color Collector for profile, cdef and pclr data
 103 @return Returns true if successful, returns false otherwise
 104 */
 105 static bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
 106     opj_jp2_box_t *box, opj_jp2_color_t *color);
 107 /**
 108 Collect component mapping data
 109 @param jp2 JP2 handle
 110 @param cio Input buffer stream
 111 @param box
 112 @param color Collector for profile, cdef and pclr data
 113 @return Returns true if successful, returns false otherwise
 114 */
 115 static bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
 116     opj_jp2_box_t *box, opj_jp2_color_t *color);
 117 /**
 118 Collect colour specification data
 119 @param jp2 JP2 handle
 120 @param cio Input buffer stream
 121 @param box
 122 @param color Collector for profile, cdef and pclr data
 123 @return Returns true if successful, returns false otherwise
 124 */
 125 static bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
 126     opj_jp2_box_t *box, opj_jp2_color_t *color);
 127 /*@}*/
 128
 129 /*@}*/
 130
 131 /* ----------------------------------------------------------------------- */
 132
 133 static bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) {
 134         box->init_pos = cio_tell(cio);
 135         box->length = cio_read(cio, 4);
 136         box->type = cio_read(cio, 4);
 137         if (box->length == 1) {
 138                 if (cio_read(cio, 4) != 0) {
 139                         opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
 140                         return false;
 141                 }
 142                 box->length = cio_read(cio, 4);
 143                 if (box->length == 0)
 144                         box->length = cio_numbytesleft(cio) + 12;
 145         }
 146         else if (box->length == 0) {
 147                 box->length = cio_numbytesleft(cio) + 8;
 148         }
 149
 150         return true;
 151 }
 152
 153 #if 0
 154 static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
 155         unsigned int i;
 156         opj_jp2_box_t box;
 157
 158         box.init_pos = cio_tell(cio);
 159         cio_skip(cio, 4);
 160         cio_write(cio, JP2_URL, 4);     /* DBTL */
 161         cio_write(cio, 0, 1);           /* VERS */
 162         cio_write(cio, 0, 3);           /* FLAG */
 163
 164         if(Idx_file) {
 165                 for (i = 0; i < strlen(Idx_file); i++) {
 166                         cio_write(cio, Idx_file[i], 1);
 167                 }
 168         }
 169
 170         box.length = cio_tell(cio) - box.init_pos;
 171         cio_seek(cio, box.init_pos);
 172         cio_write(cio, box.length, 4);  /* L */
 173         cio_seek(cio, box.init_pos + box.length);
 174 }
 175 #endif
 176
 177 static bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
 178         opj_jp2_box_t box;
 179
 180         opj_common_ptr cinfo = jp2->cinfo;
 181
 182         jp2_read_boxhdr(cinfo, cio, &box);
 183         if (JP2_IHDR != box.type) {
 184                 opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n");
 185                 return false;
 186         }
 187
 188         jp2->h = cio_read(cio, 4);                      /* HEIGHT */
 189         jp2->w = cio_read(cio, 4);                      /* WIDTH */
 190         jp2->numcomps = cio_read(cio, 2);       /* NC */
 191         jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
 192
 193         jp2->bpc = cio_read(cio, 1);            /* BPC */
 194
 195         jp2->C = cio_read(cio, 1);                      /* C */
 196         jp2->UnkC = cio_read(cio, 1);           /* UnkC */
 197         jp2->IPR = cio_read(cio, 1);            /* IPR */
 198
 199         if (cio_tell(cio) - box.init_pos != box.length) {
 200                 opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n");
 201                 return false;
 202         }
 203
 204         return true;
 205 }
 206
 207 static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
 208         opj_jp2_box_t box;
 209
 210         box.init_pos = cio_tell(cio);
 211         cio_skip(cio, 4);
 212         cio_write(cio, JP2_IHDR, 4);            /* IHDR */
 213
 214         cio_write(cio, jp2->h, 4);                      /* HEIGHT */
 215         cio_write(cio, jp2->w, 4);                      /* WIDTH */
 216         cio_write(cio, jp2->numcomps, 2);       /* NC */
 217
 218         cio_write(cio, jp2->bpc, 1);            /* BPC */
 219
 220         cio_write(cio, jp2->C, 1);                      /* C : Always 7 */
 221         cio_write(cio, jp2->UnkC, 1);           /* UnkC, colorspace unknown */
 222         cio_write(cio, jp2->IPR, 1);            /* IPR, no intellectual property */
 223
 224         box.length = cio_tell(cio) - box.init_pos;
 225         cio_seek(cio, box.init_pos);
 226         cio_write(cio, box.length, 4);  /* L */
 227         cio_seek(cio, box.init_pos + box.length);
 228 }
 229
 230 static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
 231         unsigned int i;
 232         opj_jp2_box_t box;
 233
 234         box.init_pos = cio_tell(cio);
 235         cio_skip(cio, 4);
 236         cio_write(cio, JP2_BPCC, 4);    /* BPCC */
 237
 238         for (i = 0; i < jp2->numcomps; i++) {
 239                 cio_write(cio, jp2->comps[i].bpcc, 1);
 240         }
 241
 242         box.length = cio_tell(cio) - box.init_pos;
 243         cio_seek(cio, box.init_pos);
 244         cio_write(cio, box.length, 4);  /* L */
 245         cio_seek(cio, box.init_pos + box.length);
 246 }
 247
 248
 249 static bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
 250         unsigned int i;
 251         opj_jp2_box_t box;
 252
 253         opj_common_ptr cinfo = jp2->cinfo;
 254
 255         jp2_read_boxhdr(cinfo, cio, &box);
 256         if (JP2_BPCC != box.type) {
 257                 opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n");
 258                 return false;
 259         }
 260
 261         for (i = 0; i < jp2->numcomps; i++) {
 262                 jp2->comps[i].bpcc = cio_read(cio, 1);
 263         }
 264
 265         if (cio_tell(cio) - box.init_pos != box.length) {
 266                 opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
 267                 return false;
 268         }
 269
 270         return true;
 271 }
 272
 273 static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
 274         opj_jp2_box_t box;
 275
 276         box.init_pos = cio_tell(cio);
 277         cio_skip(cio, 4);
 278         cio_write(cio, JP2_COLR, 4);            /* COLR */
 279
 280         cio_write(cio, jp2->meth, 1);           /* METH */
 281         cio_write(cio, jp2->precedence, 1);     /* PRECEDENCE */
 282         cio_write(cio, jp2->approx, 1);         /* APPROX */
 283
 284         if (jp2->meth == 1) {
 285                 cio_write(cio, jp2->enumcs, 4); /* EnumCS */
 286         } else {
 287                 cio_write(cio, 0, 1);                   /* PROFILE (??) */
 288         }
 289
 290         box.length = cio_tell(cio) - box.init_pos;
 291         cio_seek(cio, box.init_pos);
 292         cio_write(cio, box.length, 4);  /* L */
 293         cio_seek(cio, box.init_pos + box.length);
 294 }
 295
 296 static void jp2_free_pclr(opj_jp2_color_t *color)
 297 {
 298     opj_free(color->jp2_pclr->channel_sign);
 299     opj_free(color->jp2_pclr->channel_size);
 300     opj_free(color->jp2_pclr->entries);
 301
 302         if(color->jp2_pclr->cmap) opj_free(color->jp2_pclr->cmap);
 303
 304     opj_free(color->jp2_pclr); color->jp2_pclr = NULL;
 305 }
 306
 307 static void free_color_data(opj_jp2_color_t *color)
 308 {
 309         if(color->jp2_pclr)
 310    {
 311         jp2_free_pclr(color);
 312    }
 313         if(color->jp2_cdef)
 314    {
 315         if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
 316         opj_free(color->jp2_cdef);
 317    }
 318         if(color->icc_profile_buf) opj_free(color->icc_profile_buf);
 319 }
 320
 321 static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image)
 322 {
 323         opj_image_comp_t *old_comps, *new_comps;
 324         unsigned char *channel_size, *channel_sign;
 325         unsigned int *entries;
 326         opj_jp2_cmap_comp_t *cmap;
 327         int *src, *dst;
 328         unsigned int j, max;
 329         unsigned short i, nr_channels, cmp, pcol;
 330         int k, top_k;
 331
 332         channel_size = color->jp2_pclr->channel_size;
 333         channel_sign = color->jp2_pclr->channel_sign;
 334         entries = color->jp2_pclr->entries;
 335         cmap = color->jp2_pclr->cmap;
 336         nr_channels = color->jp2_pclr->nr_channels;
 337
 338         old_comps = image->comps;
 339         new_comps = (opj_image_comp_t*)
 340          opj_malloc(nr_channels * sizeof(opj_image_comp_t));
 341
 342         for(i = 0; i < nr_channels; ++i)
 343    {
 344         pcol = cmap[i].pcol; cmp = cmap[i].cmp;
 345
 346         new_comps[pcol] = old_comps[cmp];
 347
 348         if(cmap[i].mtyp == 0) /* Direct use */
 349   {
 350         old_comps[cmp].data = NULL; continue;
 351   }
 352 /* Palette mapping: */
 353         new_comps[pcol].data = (int*)
 354          opj_malloc(old_comps[cmp].w * old_comps[cmp].h * sizeof(int));
 355         new_comps[pcol].prec = channel_size[i];
 356         new_comps[pcol].sgnd = channel_sign[i];
 357    }
 358         top_k = color->jp2_pclr->nr_entries - 1;
 359
 360         for(i = 0; i < nr_channels; ++i)
 361    {
 362 /* Direct use: */
 363         if(cmap[i].mtyp == 0) continue;
 364
 365 /* Palette mapping: */
 366         cmp = cmap[i].cmp; pcol = cmap[i].pcol;
 367         src = old_comps[cmp].data;
 368         dst = new_comps[pcol].data;
 369         max = new_comps[pcol].w * new_comps[pcol].h;
 370
 371         for(j = 0; j < max; ++j)
 372   {
 373 /* The index */
 374         if((k = src[j]) < 0) k = 0; else if(k > top_k) k = top_k;
 375 /* The colour */
 376         dst[j] = entries[k * nr_channels + pcol];
 377   }
 378    }
 379         max = image->numcomps;
 380         for(i = 0; i < max; ++i)
 381    {
 382         if(old_comps[i].data) opj_free(old_comps[i].data);
 383    }
 384         opj_free(old_comps);
 385         image->comps = new_comps;
 386         image->numcomps = nr_channels;
 387
 388         jp2_free_pclr(color);
 389
 390 }/* apply_pclr() */
 391
 392 static bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
 393         opj_jp2_box_t *box, opj_jp2_color_t *color)
 394 {
 395         opj_jp2_pclr_t *jp2_pclr;
 396         unsigned char *channel_size, *channel_sign;
 397         unsigned int *entries;
 398         unsigned short nr_entries, nr_channels;
 399         unsigned short i, j;
 400         unsigned char uc;
 401
 402 /* Part 1, I.5.3.4: 'There shall be at most one Palette box inside
 403  * a JP2 Header box' :
 404 */
 405         if(color->jp2_pclr) return false;
 406
 407         nr_entries = cio_read(cio, 2); /* NE */
 408         nr_channels = cio_read(cio, 1);/* NPC */
 409
 410         entries = (unsigned int*)
 411          opj_malloc(nr_channels * nr_entries * sizeof(unsigned int));
 412         channel_size = (unsigned char*)opj_malloc(nr_channels);
 413         channel_sign = (unsigned char*)opj_malloc(nr_channels);
 414
 415         jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t));
 416         jp2_pclr->channel_sign = channel_sign;
 417         jp2_pclr->channel_size = channel_size;
 418         jp2_pclr->entries = entries;
 419         jp2_pclr->nr_entries = nr_entries;
 420         jp2_pclr->nr_channels = nr_channels;
 421         jp2_pclr->cmap = NULL;
 422
 423         color->jp2_pclr = jp2_pclr;
 424
 425         for(i = 0; i < nr_channels; ++i)
 426    {
 427         uc = cio_read(cio, 1); /* Bi */
 428         channel_size[i] = (uc & 0x7f) + 1;
 429         channel_sign[i] = (uc & 0x80)?1:0;
 430    }
 431
 432         for(j = 0; j < nr_entries; ++j)
 433    {
 434         for(i = 0; i < nr_channels; ++i)
 435   {
 436 /* Cji */
 437         *entries++ = cio_read(cio, channel_size[i]>>3);
 438   }
 439    }
 440
 441         return true;
 442 }/* jp2_read_pclr() */
 443
 444 static bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
 445         opj_jp2_box_t *box, opj_jp2_color_t *color)
 446 {
 447         opj_jp2_cmap_comp_t *cmap;
 448         unsigned short i, nr_channels;
 449
 450 /* Need nr_channels: */
 451         if(color->jp2_pclr == NULL) return false;
 452
 453 /* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
 454  * inside a JP2 Header box' :
 455 */
 456         if(color->jp2_pclr->cmap) return false;
 457
 458         nr_channels = color->jp2_pclr->nr_channels;
 459         cmap = (opj_jp2_cmap_comp_t*)
 460          opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
 461
 462         for(i = 0; i < nr_channels; ++i)
 463    {
 464         cmap[i].cmp = cio_read(cio, 2);
 465         cmap[i].mtyp = cio_read(cio, 1);
 466         cmap[i].pcol = cio_read(cio, 1);
 467
 468    }
 469         color->jp2_pclr->cmap = cmap;
 470
 471         return true;
 472 }/* jp2_read_cmap() */
 473
 474 static void jp2_apply_cdef(opj_image_t *image, opj_jp2_color_t *color)
 475 {
 476         opj_jp2_cdef_info_t *info;
 477         int color_space;
 478         unsigned short i, n, cn, typ, asoc, acn;
 479
 480         color_space = image->color_space;
 481         info = color->jp2_cdef->info;
 482         n = color->jp2_cdef->n;
 483
 484         for(i = 0; i < n; ++i)
 485    {
 486 /* WATCH: acn = asoc - 1 ! */
 487         if((asoc = info[i].asoc) == 0) continue;
 488
 489         cn = info[i].cn; typ = info[i].typ; acn = asoc - 1;
 490
 491         if(cn != acn)
 492   {
 493         opj_image_comp_t saved;
 494
 495         memcpy(&saved, &image->comps[cn], sizeof(opj_image_comp_t));
 496         memcpy(&image->comps[cn], &image->comps[acn], sizeof(opj_image_comp_t));
 497         memcpy(&image->comps[acn], &saved, sizeof(opj_image_comp_t));
 498
 499         info[i].asoc = cn + 1;
 500         info[acn].asoc = info[acn].cn + 1;
 501   }
 502    }
 503         if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
 504
 505         opj_free(color->jp2_cdef); color->jp2_cdef = NULL;
 506
 507 }/* jp2_apply_cdef() */
 508
 509 static bool jp2_read_cdef(opj_jp2_t *jp2, opj_cio_t *cio,
 510         opj_jp2_box_t *box, opj_jp2_color_t *color)
 511 {
 512         opj_jp2_cdef_info_t *info;
 513         unsigned short i, n;
 514
 515 /* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
 516  * inside a JP2 Header box.'
 517 */
 518         if(color->jp2_cdef) return false;
 519
 520         if((n = cio_read(cio, 2)) == 0) return false; /* szukw000: FIXME */
 521
 522         info = (opj_jp2_cdef_info_t*)
 523          opj_malloc(n * sizeof(opj_jp2_cdef_info_t));
 524
 525         color->jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
 526         color->jp2_cdef->info = info;
 527         color->jp2_cdef->n = n;
 528
 529         for(i = 0; i < n; ++i)
 530    {
 531         info[i].cn = cio_read(cio, 2);
 532         info[i].typ = cio_read(cio, 2);
 533         info[i].asoc = cio_read(cio, 2);
 534
 535    }
 536         return true;
 537 }/* jp2_read_cdef() */
 538
 539 static bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
 540         opj_jp2_box_t *box, opj_jp2_color_t *color)
 541 {
 542         int skip_len;
 543     opj_common_ptr cinfo;
 544
 545 /* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
 546  * Specification boxes after the first.'
 547 */
 548         if(color->jp2_has_colr) return false;
 549
 550         cinfo = jp2->cinfo;
 551
 552         jp2->meth = cio_read(cio, 1);           /* METH */
 553         jp2->precedence = cio_read(cio, 1);     /* PRECEDENCE */
 554         jp2->approx = cio_read(cio, 1);         /* APPROX */
 555
 556         if (jp2->meth == 1)
 557    {
 558         jp2->enumcs = cio_read(cio, 4); /* EnumCS */
 559    }
 560         else
 561    {
 562 /* skip PROFILE */
 563         skip_len = box->init_pos + box->length - cio_tell(cio);
 564         if (skip_len < 0)
 565   {
 566         opj_event_msg(cinfo, EVT_ERROR, "Error with COLR box size\n");
 567         return false;
 568   }
 569         if(skip_len > 0)
 570   {
 571         unsigned char *start;
 572
 573         start = cio_getbp(cio);
 574         color->icc_profile_buf = (unsigned char*)opj_malloc(skip_len);
 575         color->icc_profile_len = skip_len;
 576
 577         cio_skip(cio, box->init_pos + box->length - cio_tell(cio));
 578
 579         memcpy(color->icc_profile_buf, start, skip_len);
 580   }
 581    }
 582
 583         if (cio_tell(cio) - box->init_pos != box->length)
 584    {
 585         opj_event_msg(cinfo, EVT_ERROR, "Error with COLR Box\n");
 586         return false;
 587    }
 588         color->jp2_has_colr = 1;
 589
 590         return true;
 591 }/* jp2_read_colr() */
 592
 593 bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color)
 594 {
 595         opj_jp2_box_t box;
 596         unsigned int jp2h_end;
 597
 598         opj_common_ptr cinfo = jp2->cinfo;
 599
 600         jp2_read_boxhdr(cinfo, cio, &box);
 601         do
 602    {
 603         if (JP2_JP2H != box.type)
 604   {
 605         if (box.type == JP2_JP2C)
 606  {
 607         opj_event_msg(cinfo, EVT_ERROR, "Expected JP2H Marker\n");
 608         return false;
 609  }
 610         cio_skip(cio, box.length - 8);
 611
 612         if(cio->bp >= cio->end) return false;
 613
 614         jp2_read_boxhdr(cinfo, cio, &box);
 615   }
 616    } while(JP2_JP2H != box.type);
 617
 618         if (!jp2_read_ihdr(jp2, cio))
 619                 return false;
 620         jp2h_end = box.init_pos + box.length;
 621
 622         if (jp2->bpc == 255)
 623    {
 624         if (!jp2_read_bpcc(jp2, cio))
 625                 return false;
 626    }
 627         jp2_read_boxhdr(cinfo, cio, &box);
 628
 629         while(cio_tell(cio) < jp2h_end)
 630    {
 631         if(box.type == JP2_COLR)
 632   {
 633         if( !jp2_read_colr(jp2, cio, &box, color))
 634  {
 635     cio_seek(cio, box.init_pos + 8);
 636     cio_skip(cio, box.length - 8);
 637  }
 638     jp2_read_boxhdr(cinfo, cio, &box);
 639     continue;
 640   }
 641     if(box.type == JP2_CDEF)
 642   {
 643     if( !jp2_read_cdef(jp2, cio, &box, color))
 644  {
 645     cio_seek(cio, box.init_pos + 8);
 646     cio_skip(cio, box.length - 8);
 647  }
 648     jp2_read_boxhdr(cinfo, cio, &box);
 649     continue;
 650   }
 651     if(box.type == JP2_PCLR)
 652   {
 653     if( !jp2_read_pclr(jp2, cio, &box, color))
 654  {
 655     cio_seek(cio, box.init_pos + 8);
 656     cio_skip(cio, box.length - 8);
 657  }
 658     jp2_read_boxhdr(cinfo, cio, &box);
 659     continue;
 660   }
 661     if(box.type == JP2_CMAP)
 662   {
 663     if( !jp2_read_cmap(jp2, cio, &box, color))
 664  {
 665     cio_seek(cio, box.init_pos + 8);
 666     cio_skip(cio, box.length - 8);
 667  }
 668     jp2_read_boxhdr(cinfo, cio, &box);
 669     continue;
 670   }
 671         cio_seek(cio, box.init_pos + 8);
 672         cio_skip(cio, box.length - 8);
 673         jp2_read_boxhdr(cinfo, cio, &box);
 674
 675    }/* while(cio_tell(cio) < box_end) */
 676
 677         cio_seek(cio, jp2h_end);
 678
 679 /* Part 1, I.5.3.3 : 'must contain at least one' */
 680         return (color->jp2_has_colr == 1);
 681
 682 }/* jp2_read_jp2h() */
 683
 684 opj_image_t* jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio,
 685         opj_codestream_info_t *cstr_info)
 686 {
 687         opj_common_ptr cinfo;
 688         opj_image_t *image = NULL;
 689         opj_jp2_color_t color;
 690
 691         if(!jp2 || !cio)
 692    {
 693         return NULL;
 694    }
 695         memset(&color, 0, sizeof(opj_jp2_color_t));
 696         cinfo = jp2->cinfo;
 697
 698 /* JP2 decoding */
 699         if(!jp2_read_struct(jp2, cio, &color))
 700    {
 701         free_color_data(&color);
 702         opj_event_msg(cinfo, EVT_ERROR, "Failed to decode jp2 structure\n");
 703         return NULL;
 704    }
 705
 706 /* J2K decoding */
 707         image = j2k_decode(jp2->j2k, cio, cstr_info);
 708
 709         if(!image)
 710    {
 711         free_color_data(&color);
 712         opj_event_msg(cinfo, EVT_ERROR, "Failed to decode J2K image\n");
 713         return NULL;
 714    }
 715
 716 /* Set Image Color Space */
 717         if (jp2->enumcs == 16)
 718                 image->color_space = CLRSPC_SRGB;
 719         else if (jp2->enumcs == 17)
 720                 image->color_space = CLRSPC_GRAY;
 721         else if (jp2->enumcs == 18)
 722                 image->color_space = CLRSPC_SYCC;
 723         else
 724                 image->color_space = CLRSPC_UNKNOWN;
 725
 726         if(color.jp2_cdef)
 727    {
 728         jp2_apply_cdef(image, &color);
 729    }
 730         if(color.jp2_pclr)
 731    {
 732 /* Part 1, I.5.3.4: Either both or none : */
 733         if( !color.jp2_pclr->cmap)
 734          jp2_free_pclr(&color);
 735         else
 736          jp2_apply_pclr(&color, image);
 737    }
 738         if(color.icc_profile_buf)
 739    {
 740         image->icc_profile_buf = color.icc_profile_buf;
 741         color.icc_profile_buf = NULL;
 742         image->icc_profile_len = color.icc_profile_len;
 743    }
 744         return image;
 745
 746 }/* jp2_decode() */
 747
 748
 749 void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
 750         opj_jp2_box_t box;
 751
 752         box.init_pos = cio_tell(cio);
 753         cio_skip(cio, 4);
 754         cio_write(cio, JP2_JP2H, 4);    /* JP2H */
 755
 756         jp2_write_ihdr(jp2, cio);
 757
 758         if (jp2->bpc == 255) {
 759                 jp2_write_bpcc(jp2, cio);
 760         }
 761         jp2_write_colr(jp2, cio);
 762
 763         box.length = cio_tell(cio) - box.init_pos;
 764         cio_seek(cio, box.init_pos);
 765         cio_write(cio, box.length, 4);  /* L */
 766         cio_seek(cio, box.init_pos + box.length);
 767 }
 768
 769 static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
 770         unsigned int i;
 771         opj_jp2_box_t box;
 772
 773         box.init_pos = cio_tell(cio);
 774         cio_skip(cio, 4);
 775         cio_write(cio, JP2_FTYP, 4);            /* FTYP */
 776
 777         cio_write(cio, jp2->brand, 4);          /* BR */
 778         cio_write(cio, jp2->minversion, 4);     /* MinV */
 779
 780         for (i = 0; i < jp2->numcl; i++) {
 781                 cio_write(cio, jp2->cl[i], 4);  /* CL */
 782         }
 783
 784         box.length = cio_tell(cio) - box.init_pos;
 785         cio_seek(cio, box.init_pos);
 786         cio_write(cio, box.length, 4);  /* L */
 787         cio_seek(cio, box.init_pos + box.length);
 788 }
 789
 790 static bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
 791         int i;
 792         opj_jp2_box_t box;
 793
 794         opj_common_ptr cinfo = jp2->cinfo;
 795
 796         jp2_read_boxhdr(cinfo, cio, &box);
 797
 798         if (JP2_FTYP != box.type) {
 799                 opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n");
 800                 return false;
 801         }
 802
 803         jp2->brand = cio_read(cio, 4);          /* BR */
 804         jp2->minversion = cio_read(cio, 4);     /* MinV */
 805         jp2->numcl = (box.length - 16) / 4;
 806         jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
 807
 808         for (i = 0; i < (int)jp2->numcl; i++) {
 809                 jp2->cl[i] = cio_read(cio, 4);  /* CLi */
 810         }
 811
 812         if (cio_tell(cio) - box.init_pos != box.length) {
 813                 opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n");
 814                 return false;
 815         }
 816
 817         return true;
 818 }
 819
 820 static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
 821         unsigned int j2k_codestream_offset, j2k_codestream_length;
 822         opj_jp2_box_t box;
 823
 824         opj_j2k_t *j2k = jp2->j2k;
 825
 826         box.init_pos = cio_tell(cio);
 827         cio_skip(cio, 4);
 828         cio_write(cio, JP2_JP2C, 4);    /* JP2C */
 829
 830         /* J2K encoding */
 831         j2k_codestream_offset = cio_tell(cio);
 832         if(!j2k_encode(j2k, cio, image, cstr_info)) {
 833                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Failed to encode image\n");
 834                 return 0;
 835         }
 836         j2k_codestream_length = cio_tell(cio) - j2k_codestream_offset;
 837
 838         jp2->j2k_codestream_offset = j2k_codestream_offset;
 839         jp2->j2k_codestream_length = j2k_codestream_length;
 840
 841         box.length = 8 + jp2->j2k_codestream_length;
 842         cio_seek(cio, box.init_pos);
 843         cio_write(cio, box.length, 4);  /* L */
 844         cio_seek(cio, box.init_pos + box.length);
 845
 846         return box.length;
 847 }
 848
 849 static bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset) {
 850         opj_jp2_box_t box;
 851
 852         opj_common_ptr cinfo = jp2->cinfo;
 853
 854         jp2_read_boxhdr(cinfo, cio, &box);
 855         do {
 856                 if(JP2_JP2C != box.type) {
 857                         cio_skip(cio, box.length - 8);
 858                         jp2_read_boxhdr(cinfo, cio, &box);
 859                 }
 860         } while(JP2_JP2C != box.type);
 861
 862         *j2k_codestream_offset = cio_tell(cio);
 863         *j2k_codestream_length = box.length - 8;
 864
 865         return true;
 866 }
 867
 868 static void jp2_write_jp(opj_cio_t *cio) {
 869         opj_jp2_box_t box;
 870
 871         box.init_pos = cio_tell(cio);
 872         cio_skip(cio, 4);
 873         cio_write(cio, JP2_JP, 4);              /* JP2 signature */
 874         cio_write(cio, 0x0d0a870a, 4);
 875
 876         box.length = cio_tell(cio) - box.init_pos;
 877         cio_seek(cio, box.init_pos);
 878         cio_write(cio, box.length, 4);  /* L */
 879         cio_seek(cio, box.init_pos + box.length);
 880 }
 881
 882 static bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) {
 883         opj_jp2_box_t box;
 884
 885         opj_common_ptr cinfo = jp2->cinfo;
 886
 887         jp2_read_boxhdr(cinfo, cio, &box);
 888         if (JP2_JP != box.type) {
 889                 opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n");
 890                 return false;
 891         }
 892         if (0x0d0a870a != cio_read(cio, 4)) {
 893                 opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n");
 894                 return false;
 895         }
 896         if (cio_tell(cio) - box.init_pos != box.length) {
 897                 opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n");
 898                 return false;
 899         }
 900
 901         return true;
 902 }
 903
 904
 905 static bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
 906         opj_jp2_color_t *color) {
 907         if (!jp2_read_jp(jp2, cio))
 908                 return false;
 909         if (!jp2_read_ftyp(jp2, cio))
 910                 return false;
 911         if (!jp2_read_jp2h(jp2, cio, color))
 912                 return false;
 913         if (!jp2_read_jp2c(jp2, cio, &jp2->j2k_codestream_length, &jp2->j2k_codestream_offset))
 914                 return false;
 915
 916         return true;
 917 }
 918
 919 /* ----------------------------------------------------------------------- */
 920 /* JP2 decoder interface                                             */
 921 /* ----------------------------------------------------------------------- */
 922
 923 opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) {
 924         opj_jp2_t *jp2 = (opj_jp2_t*) opj_calloc(1, sizeof(opj_jp2_t));
 925         if(jp2) {
 926                 jp2->cinfo = cinfo;
 927                 /* create the J2K codec */
 928                 jp2->j2k = j2k_create_decompress(cinfo);
 929                 if(jp2->j2k == NULL) {
 930                         jp2_destroy_decompress(jp2);
 931                         return NULL;
 932                 }
 933         }
 934         return jp2;
 935 }
 936
 937 void jp2_destroy_decompress(opj_jp2_t *jp2) {
 938         if(jp2) {
 939                 /* destroy the J2K codec */
 940                 j2k_destroy_decompress(jp2->j2k);
 941
 942                 if(jp2->comps) {
 943                         opj_free(jp2->comps);
 944                 }
 945                 if(jp2->cl) {
 946                         opj_free(jp2->cl);
 947                 }
 948                 opj_free(jp2);
 949         }
 950 }
 951
 952 void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) {
 953         /* setup the J2K codec */
 954         j2k_setup_decoder(jp2->j2k, parameters);
 955         /* further JP2 initializations go here */
 956 }
 957
 958 /* ----------------------------------------------------------------------- */
 959 /* JP2 encoder interface                                             */
 960 /* ----------------------------------------------------------------------- */
 961
 962 opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo) {
 963         opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
 964         if(jp2) {
 965                 jp2->cinfo = cinfo;
 966                 /* create the J2K codec */
 967                 jp2->j2k = j2k_create_compress(cinfo);
 968                 if(jp2->j2k == NULL) {
 969                         jp2_destroy_compress(jp2);
 970                         return NULL;
 971                 }
 972         }
 973         return jp2;
 974 }
 975
 976 void jp2_destroy_compress(opj_jp2_t *jp2) {
 977         if(jp2) {
 978                 /* destroy the J2K codec */
 979                 j2k_destroy_compress(jp2->j2k);
 980
 981                 if(jp2->comps) {
 982                         opj_free(jp2->comps);
 983                 }
 984                 if(jp2->cl) {
 985                         opj_free(jp2->cl);
 986                 }
 987                 opj_free(jp2);
 988         }
 989 }
 990
 991 void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image) {
 992         int i;
 993         int depth_0, sign;
 994
 995         if(!jp2 || !parameters || !image)
 996                 return;
 997
 998         /* setup the J2K codec */
 999         /* ------------------- */
1000
1001         /* Check if number of components respects standard */
1002         if (image->numcomps < 1 || image->numcomps > 16384) {
1003                 opj_event_msg(jp2->cinfo, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
1004                 return;
1005         }
1006
1007         j2k_setup_encoder(jp2->j2k, parameters, image);
1008
1009         /* setup the JP2 codec */
1010         /* ------------------- */
1011
1012         /* Profile box */
1013
1014         jp2->brand = JP2_JP2;   /* BR */
1015         jp2->minversion = 0;    /* MinV */
1016         jp2->numcl = 1;
1017         jp2->cl = (unsigned int*) opj_malloc(jp2->numcl * sizeof(unsigned int));
1018         jp2->cl[0] = JP2_JP2;   /* CL0 : JP2 */
1019
1020         /* Image Header box */
1021
1022         jp2->numcomps = image->numcomps;        /* NC */
1023         jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
1024         jp2->h = image->y1 - image->y0;         /* HEIGHT */
1025         jp2->w = image->x1 - image->x0;         /* WIDTH */
1026         /* BPC */
1027         depth_0 = image->comps[0].prec - 1;
1028         sign = image->comps[0].sgnd;
1029         jp2->bpc = depth_0 + (sign << 7);
1030         for (i = 1; i < image->numcomps; i++) {
1031                 int depth = image->comps[i].prec - 1;
1032                 sign = image->comps[i].sgnd;
1033                 if (depth_0 != depth)
1034                         jp2->bpc = 255;
1035         }
1036         jp2->C = 7;                     /* C : Always 7 */
1037         jp2->UnkC = 0;          /* UnkC, colorspace specified in colr box */
1038         jp2->IPR = 0;           /* IPR, no intellectual property */
1039
1040         /* BitsPerComponent box */
1041
1042         for (i = 0; i < image->numcomps; i++) {
1043                 jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
1044         }
1045
1046         /* Colour Specification box */
1047
1048         if ((image->numcomps == 1 || image->numcomps == 3) && (jp2->bpc != 255)) {
1049                 jp2->meth = 1;  /* METH: Enumerated colourspace */
1050         } else {
1051                 jp2->meth = 2;  /* METH: Restricted ICC profile */
1052         }
1053         if (jp2->meth == 1) {
1054                 if (image->color_space == 1)
1055                         jp2->enumcs = 16;       /* sRGB as defined by IEC 61966-2.1 */
1056                 else if (image->color_space == 2)
1057                         jp2->enumcs = 17;       /* greyscale */
1058                 else if (image->color_space == 3)
1059                         jp2->enumcs = 18;       /* YUV */
1060         } else {
1061                 jp2->enumcs = 0;                /* PROFILE (??) */
1062         }
1063         jp2->precedence = 0;    /* PRECEDENCE */
1064         jp2->approx = 0;                /* APPROX */
1065
1066 }
1067
1068 bool jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
1069
1070         /* JP2 encoding */
1071
1072         /* JPEG 2000 Signature box */
1073         jp2_write_jp(cio);
1074         /* File Type box */
1075         jp2_write_ftyp(jp2, cio);
1076         /* JP2 Header box */
1077         jp2_write_jp2h(jp2, cio);
1078
1079         /* J2K encoding */
1080
1081         if(!jp2_write_jp2c(jp2, cio, image, cstr_info)) {
1082                 opj_event_msg(jp2->cinfo, EVT_ERROR, "Failed to encode image\n");
1083                 return false;
1084         }
1085
1086         return true;
1087 }
1088
1089