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
11
* Redistribution and use in source and binary forms, with or without
12
* modification, are permitted provided that the following conditions
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.
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.
32
#include "opj_includes.h"
34
/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
37
/** @name Local static functions */
42
@param cinfo Codec context info
43
@param cio Input stream
45
@return Returns true if successful, returns false otherwise
47
static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box);
48
/*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
50
Read the IHDR box - Image Header box
52
@param cio Input buffer stream
53
@return Returns true if successful, returns false otherwise
55
static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
56
static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
57
static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
58
static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
59
static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio);
61
Write the FTYP box - File type box
63
@param cio Output buffer stream
65
static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
67
Read the FTYP box - File type box
69
@param cio Input buffer stream
70
@return Returns true if successful, returns false otherwise
72
static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
73
static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
74
static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset);
75
static void jp2_write_jp(opj_cio_t *cio);
77
Read the JP box - JPEG 2000 signature
79
@param cio Input buffer stream
80
@return Returns true if successful, returns false otherwise
82
static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio);
84
Decode the structure of a JP2 file
86
@param cio Input buffer stream
87
@param color Collector for profile, cdef and pclr data
88
@return Returns true if successful, returns false otherwise
90
static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
91
opj_jp2_color_t *color);
93
Apply collected palette data
94
@param color Collector for profile, cdef and pclr data
97
static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image, opj_common_ptr cinfo);
100
@param jp2 JP2 handle
101
@param cio Input buffer stream
103
@param color Collector for profile, cdef and pclr data
104
@return Returns true if successful, returns false otherwise
106
static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
107
opj_jp2_box_t *box, opj_jp2_color_t *color);
109
Collect component mapping data
110
@param jp2 JP2 handle
111
@param cio Input buffer stream
113
@param color Collector for profile, cdef and pclr data
114
@return Returns true if successful, returns false otherwise
116
static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
117
opj_jp2_box_t *box, opj_jp2_color_t *color);
119
Collect colour specification data
120
@param jp2 JP2 handle
121
@param cio Input buffer stream
123
@param color Collector for profile, cdef and pclr data
124
@return Returns true if successful, returns false otherwise
126
static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
127
opj_jp2_box_t *box, opj_jp2_color_t *color);
129
Write file Index (superbox)
130
@param[in] offset_jp2c offset of jp2c box
131
@param[in] length_jp2c length of jp2c box
132
@param[in] offset_idx offset of cidx box
133
@param[in] length_idx length of cidx box
134
@param[in] cio file output handle
135
@return length of fidx box
137
static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
139
Write index Finder box
140
@param[in] offset offset of fidx box
141
@param[in] length length of fidx box
142
@param[in] cio file output handle
144
static void write_iptr( int offset, int length, opj_cio_t *cio);
147
@param[in] offset_jp2c offset of jp2c box
148
@param[in] length_jp2c length of jp2c box
149
@param[in] offset_idx offset of cidx box
150
@param[in] length_idx length of cidx box
151
@param[in] cio file output handle
153
static void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
158
/* ----------------------------------------------------------------------- */
160
static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) {
161
box->init_pos = cio_tell(cio);
162
box->length = cio_read(cio, 4);
163
box->type = cio_read(cio, 4);
164
if (box->length == 1) {
165
if (cio_read(cio, 4) != 0) {
166
opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
169
box->length = cio_read(cio, 4);
170
if (box->length == 0)
171
box->length = cio_numbytesleft(cio) + 12;
173
else if (box->length == 0) {
174
box->length = cio_numbytesleft(cio) + 8;
181
static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
185
box.init_pos = cio_tell(cio);
187
cio_write(cio, JP2_URL, 4); /* DBTL */
188
cio_write(cio, 0, 1); /* VERS */
189
cio_write(cio, 0, 3); /* FLAG */
192
for (i = 0; i < strlen(Idx_file); i++) {
193
cio_write(cio, Idx_file[i], 1);
197
box.length = cio_tell(cio) - box.init_pos;
198
cio_seek(cio, box.init_pos);
199
cio_write(cio, box.length, 4); /* L */
200
cio_seek(cio, box.init_pos + box.length);
204
static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
207
opj_common_ptr cinfo = jp2->cinfo;
209
jp2_read_boxhdr(cinfo, cio, &box);
210
if (JP2_IHDR != box.type) {
211
opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n");
215
jp2->h = cio_read(cio, 4); /* HEIGHT */
216
jp2->w = cio_read(cio, 4); /* WIDTH */
217
jp2->numcomps = cio_read(cio, 2); /* NC */
218
jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
220
jp2->bpc = cio_read(cio, 1); /* BPC */
222
jp2->C = cio_read(cio, 1); /* C */
223
jp2->UnkC = cio_read(cio, 1); /* UnkC */
224
jp2->IPR = cio_read(cio, 1); /* IPR */
226
if (cio_tell(cio) - box.init_pos != box.length) {
227
opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n");
234
static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
237
box.init_pos = cio_tell(cio);
239
cio_write(cio, JP2_IHDR, 4); /* IHDR */
241
cio_write(cio, jp2->h, 4); /* HEIGHT */
242
cio_write(cio, jp2->w, 4); /* WIDTH */
243
cio_write(cio, jp2->numcomps, 2); /* NC */
245
cio_write(cio, jp2->bpc, 1); /* BPC */
247
cio_write(cio, jp2->C, 1); /* C : Always 7 */
248
cio_write(cio, jp2->UnkC, 1); /* UnkC, colorspace unknown */
249
cio_write(cio, jp2->IPR, 1); /* IPR, no intellectual property */
251
box.length = cio_tell(cio) - box.init_pos;
252
cio_seek(cio, box.init_pos);
253
cio_write(cio, box.length, 4); /* L */
254
cio_seek(cio, box.init_pos + box.length);
257
static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
261
box.init_pos = cio_tell(cio);
263
cio_write(cio, JP2_BPCC, 4); /* BPCC */
265
for (i = 0; i < jp2->numcomps; i++) {
266
cio_write(cio, jp2->comps[i].bpcc, 1);
269
box.length = cio_tell(cio) - box.init_pos;
270
cio_seek(cio, box.init_pos);
271
cio_write(cio, box.length, 4); /* L */
272
cio_seek(cio, box.init_pos + box.length);
276
static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
280
opj_common_ptr cinfo = jp2->cinfo;
282
jp2_read_boxhdr(cinfo, cio, &box);
283
if (JP2_BPCC != box.type) {
284
opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n");
288
for (i = 0; i < jp2->numcomps; i++) {
289
jp2->comps[i].bpcc = cio_read(cio, 1);
292
if (cio_tell(cio) - box.init_pos != box.length) {
293
opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
300
static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
303
box.init_pos = cio_tell(cio);
305
cio_write(cio, JP2_COLR, 4); /* COLR */
307
cio_write(cio, jp2->meth, 1); /* METH */
308
cio_write(cio, jp2->precedence, 1); /* PRECEDENCE */
309
cio_write(cio, jp2->approx, 1); /* APPROX */
314
cio_write(cio, jp2->enumcs, 4); /* EnumCS */
316
box.length = cio_tell(cio) - box.init_pos;
317
cio_seek(cio, box.init_pos);
318
cio_write(cio, box.length, 4); /* L */
319
cio_seek(cio, box.init_pos + box.length);
322
static void jp2_free_pclr(opj_jp2_color_t *color)
324
opj_free(color->jp2_pclr->channel_sign);
325
opj_free(color->jp2_pclr->channel_size);
326
opj_free(color->jp2_pclr->entries);
328
if(color->jp2_pclr->cmap) opj_free(color->jp2_pclr->cmap);
330
opj_free(color->jp2_pclr); color->jp2_pclr = NULL;
333
static void free_color_data(opj_jp2_color_t *color)
337
jp2_free_pclr(color);
341
if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
342
opj_free(color->jp2_cdef);
344
if(color->icc_profile_buf) opj_free(color->icc_profile_buf);
347
static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image, opj_common_ptr cinfo)
349
opj_image_comp_t *old_comps, *new_comps;
350
unsigned char *channel_size, *channel_sign;
351
unsigned int *entries;
352
opj_jp2_cmap_comp_t *cmap;
355
unsigned short i, nr_channels, cmp, pcol;
358
channel_size = color->jp2_pclr->channel_size;
359
channel_sign = color->jp2_pclr->channel_sign;
360
entries = color->jp2_pclr->entries;
361
cmap = color->jp2_pclr->cmap;
362
nr_channels = color->jp2_pclr->nr_channels;
364
old_comps = image->comps;
365
new_comps = (opj_image_comp_t*)
366
opj_malloc(nr_channels * sizeof(opj_image_comp_t));
368
for(i = 0; i < nr_channels; ++i)
370
pcol = cmap[i].pcol; cmp = cmap[i].cmp;
372
if( pcol < nr_channels )
373
new_comps[pcol] = old_comps[cmp];
376
opj_event_msg(cinfo, EVT_ERROR, "Error with pcol value %d (max: %d). skipping\n", pcol, nr_channels);
380
if(cmap[i].mtyp == 0) /* Direct use */
382
old_comps[cmp].data = NULL; continue;
384
/* Palette mapping: */
385
new_comps[pcol].data = (int*)
386
opj_malloc(old_comps[cmp].w * old_comps[cmp].h * sizeof(int));
387
new_comps[pcol].prec = channel_size[i];
388
new_comps[pcol].sgnd = channel_sign[i];
390
top_k = color->jp2_pclr->nr_entries - 1;
392
for(i = 0; i < nr_channels; ++i)
395
if(cmap[i].mtyp == 0) continue;
397
/* Palette mapping: */
398
cmp = cmap[i].cmp; pcol = cmap[i].pcol;
399
src = old_comps[cmp].data;
400
dst = new_comps[pcol].data;
401
max = new_comps[pcol].w * new_comps[pcol].h;
403
for(j = 0; j < max; ++j)
406
if((k = src[j]) < 0) k = 0; else if(k > top_k) k = top_k;
408
dst[j] = entries[k * nr_channels + pcol];
411
max = image->numcomps;
412
for(i = 0; i < max; ++i)
414
if(old_comps[i].data) opj_free(old_comps[i].data);
417
image->comps = new_comps;
418
image->numcomps = nr_channels;
420
jp2_free_pclr(color);
424
static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
425
opj_jp2_box_t *box, opj_jp2_color_t *color)
427
opj_jp2_pclr_t *jp2_pclr;
428
unsigned char *channel_size, *channel_sign;
429
unsigned int *entries;
430
unsigned short nr_entries, nr_channels;
434
OPJ_ARG_NOT_USED(box);
435
OPJ_ARG_NOT_USED(jp2);
437
/* Part 1, I.5.3.4: 'There shall be at most one Palette box inside
438
* a JP2 Header box' :
440
if(color->jp2_pclr) return OPJ_FALSE;
442
nr_entries = (unsigned short)cio_read(cio, 2); /* NE */
443
nr_channels = (unsigned short)cio_read(cio, 1);/* NPC */
445
entries = (unsigned int*)
446
opj_malloc(nr_channels * nr_entries * sizeof(unsigned int));
447
channel_size = (unsigned char*)opj_malloc(nr_channels);
448
channel_sign = (unsigned char*)opj_malloc(nr_channels);
450
jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t));
451
jp2_pclr->channel_sign = channel_sign;
452
jp2_pclr->channel_size = channel_size;
453
jp2_pclr->entries = entries;
454
jp2_pclr->nr_entries = nr_entries;
455
jp2_pclr->nr_channels = nr_channels;
456
jp2_pclr->cmap = NULL;
458
color->jp2_pclr = jp2_pclr;
460
for(i = 0; i < nr_channels; ++i)
462
uc = cio_read(cio, 1); /* Bi */
463
channel_size[i] = (uc & 0x7f) + 1;
464
channel_sign[i] = (uc & 0x80)?1:0;
467
for(j = 0; j < nr_entries; ++j)
469
for(i = 0; i < nr_channels; ++i)
472
*entries++ = cio_read(cio, channel_size[i]>>3);
477
}/* jp2_read_pclr() */
479
static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
480
opj_jp2_box_t *box, opj_jp2_color_t *color)
482
opj_jp2_cmap_comp_t *cmap;
483
unsigned short i, nr_channels;
485
OPJ_ARG_NOT_USED(box);
486
OPJ_ARG_NOT_USED(jp2);
488
/* Need nr_channels: */
489
if(color->jp2_pclr == NULL) return OPJ_FALSE;
491
/* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
492
* inside a JP2 Header box' :
494
if(color->jp2_pclr->cmap) return OPJ_FALSE;
496
nr_channels = color->jp2_pclr->nr_channels;
497
cmap = (opj_jp2_cmap_comp_t*)
498
opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
500
for(i = 0; i < nr_channels; ++i)
502
cmap[i].cmp = (unsigned short)cio_read(cio, 2);
503
cmap[i].mtyp = cio_read(cio, 1);
504
cmap[i].pcol = cio_read(cio, 1);
507
color->jp2_pclr->cmap = cmap;
510
}/* jp2_read_cmap() */
512
static void jp2_apply_cdef(opj_image_t *image, opj_jp2_color_t *color)
514
opj_jp2_cdef_info_t *info;
516
unsigned short i, n, cn, typ, asoc, acn;
518
color_space = image->color_space;
519
info = color->jp2_cdef->info;
520
n = color->jp2_cdef->n;
522
for(i = 0; i < n; ++i)
524
/* WATCH: acn = asoc - 1 ! */
525
if((asoc = info[i].asoc) == 0)
527
image->comps[i].typ = info[i].typ;
531
cn = info[i].cn; typ = info[i].typ; acn = asoc - 1;
535
opj_image_comp_t saved;
537
memcpy(&saved, &image->comps[cn], sizeof(opj_image_comp_t));
538
memcpy(&image->comps[cn], &image->comps[acn], sizeof(opj_image_comp_t));
539
memcpy(&image->comps[acn], &saved, sizeof(opj_image_comp_t));
541
info[i].asoc = cn + 1;
542
info[acn].asoc = info[acn].cn + 1;
544
image->comps[cn].typ = typ;
546
if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
548
opj_free(color->jp2_cdef); color->jp2_cdef = NULL;
550
}/* jp2_apply_cdef() */
552
static opj_bool jp2_read_cdef(opj_jp2_t *jp2, opj_cio_t *cio,
553
opj_jp2_box_t *box, opj_jp2_color_t *color)
555
opj_jp2_cdef_info_t *info;
558
OPJ_ARG_NOT_USED(box);
559
OPJ_ARG_NOT_USED(jp2);
561
/* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
562
* inside a JP2 Header box.'
564
if(color->jp2_cdef) return OPJ_FALSE;
566
if((n = (unsigned short)cio_read(cio, 2)) == 0) return OPJ_FALSE; /* szukw000: FIXME */
568
info = (opj_jp2_cdef_info_t*)
569
opj_malloc(n * sizeof(opj_jp2_cdef_info_t));
571
color->jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
572
color->jp2_cdef->info = info;
573
color->jp2_cdef->n = n;
575
for(i = 0; i < n; ++i)
577
info[i].cn = (unsigned short)cio_read(cio, 2);
578
info[i].typ = (unsigned short)cio_read(cio, 2);
579
info[i].asoc = (unsigned short)cio_read(cio, 2);
583
}/* jp2_read_cdef() */
585
static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
586
opj_jp2_box_t *box, opj_jp2_color_t *color)
589
opj_common_ptr cinfo;
591
/* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
592
* Specification boxes after the first.'
594
if(color->jp2_has_colr) return OPJ_FALSE;
598
jp2->meth = cio_read(cio, 1); /* METH */
599
jp2->precedence = cio_read(cio, 1); /* PRECEDENCE */
600
jp2->approx = cio_read(cio, 1); /* APPROX */
604
jp2->enumcs = cio_read(cio, 4); /* EnumCS */
610
skip_len = box->init_pos + box->length - cio_tell(cio);
613
opj_event_msg(cinfo, EVT_ERROR, "Error with COLR box size\n");
618
unsigned char *start;
620
start = cio_getbp(cio);
621
color->icc_profile_buf = (unsigned char*)opj_malloc(skip_len);
622
color->icc_profile_len = skip_len;
624
cio_skip(cio, box->init_pos + box->length - cio_tell(cio));
626
memcpy(color->icc_profile_buf, start, skip_len);
630
if (cio_tell(cio) - box->init_pos != box->length)
632
opj_event_msg(cinfo, EVT_ERROR, "Error with COLR Box\n");
635
color->jp2_has_colr = 1;
638
}/* jp2_read_colr() */
640
opj_bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color)
645
opj_common_ptr cinfo = jp2->cinfo;
647
jp2_read_boxhdr(cinfo, cio, &box);
650
if (JP2_JP2H != box.type)
652
if (box.type == JP2_JP2C)
654
opj_event_msg(cinfo, EVT_ERROR, "Expected JP2H Marker\n");
657
cio_skip(cio, box.length - 8);
659
if(cio->bp >= cio->end) return OPJ_FALSE;
661
jp2_read_boxhdr(cinfo, cio, &box);
663
} while(JP2_JP2H != box.type);
665
if (!jp2_read_ihdr(jp2, cio))
667
jp2h_end = box.init_pos + box.length;
671
if (!jp2_read_bpcc(jp2, cio))
674
jp2_read_boxhdr(cinfo, cio, &box);
676
while(cio_tell(cio) < jp2h_end)
678
if(box.type == JP2_COLR)
680
if( !jp2_read_colr(jp2, cio, &box, color))
682
cio_seek(cio, box.init_pos + 8);
683
cio_skip(cio, box.length - 8);
685
jp2_read_boxhdr(cinfo, cio, &box);
688
if(box.type == JP2_CDEF && !jp2->ignore_pclr_cmap_cdef)
690
if( !jp2_read_cdef(jp2, cio, &box, color))
692
cio_seek(cio, box.init_pos + 8);
693
cio_skip(cio, box.length - 8);
695
jp2_read_boxhdr(cinfo, cio, &box);
698
if(box.type == JP2_PCLR && !jp2->ignore_pclr_cmap_cdef)
700
if( !jp2_read_pclr(jp2, cio, &box, color))
702
cio_seek(cio, box.init_pos + 8);
703
cio_skip(cio, box.length - 8);
705
jp2_read_boxhdr(cinfo, cio, &box);
708
if(box.type == JP2_CMAP && !jp2->ignore_pclr_cmap_cdef)
710
if( !jp2_read_cmap(jp2, cio, &box, color))
712
cio_seek(cio, box.init_pos + 8);
713
cio_skip(cio, box.length - 8);
715
jp2_read_boxhdr(cinfo, cio, &box);
718
cio_seek(cio, box.init_pos + 8);
719
cio_skip(cio, box.length - 8);
720
jp2_read_boxhdr(cinfo, cio, &box);
722
}/* while(cio_tell(cio) < box_end) */
724
cio_seek(cio, jp2h_end);
726
/* Part 1, I.5.3.3 : 'must contain at least one' */
727
return OPJ_TRUE;//(color->jp2_has_colr == 1);
729
}/* jp2_read_jp2h() */
731
opj_image_t* opj_jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio,
732
opj_codestream_info_t *cstr_info, opj_bool return_indexed)
734
opj_common_ptr cinfo;
735
opj_image_t *image = NULL;
736
opj_jp2_color_t color;
742
memset(&color, 0, sizeof(opj_jp2_color_t));
746
if(!jp2_read_struct(jp2, cio, &color))
748
free_color_data(&color);
749
opj_event_msg(cinfo, EVT_ERROR, "Failed to decode jp2 structure\n");
754
image = j2k_decode(jp2->j2k, cio, cstr_info);
758
free_color_data(&color);
759
opj_event_msg(cinfo, EVT_ERROR, "Failed to decode J2K image\n");
763
if (!jp2->ignore_pclr_cmap_cdef){
765
/* Set Image Color Space */
766
if (jp2->enumcs == 16)
767
image->color_space = CLRSPC_SRGB;
768
else if (jp2->enumcs == 17)
769
image->color_space = CLRSPC_GRAY;
770
else if (jp2->enumcs == 18)
771
image->color_space = CLRSPC_SYCC;
772
else if (jp2->enumcs == 12)
773
image->color_space = CLRSPC_CMYK;
774
else if (jp2->enumcs == 20)
775
image->color_space = CLRSPC_ERGB;
776
else if (jp2->enumcs == 24)
777
image->color_space = CLRSPC_EYCC;
779
image->color_space = CLRSPC_UNKNOWN;
783
jp2_apply_cdef(image, &color);
785
image->has_palette = OPJ_FALSE;
788
/* Part 1, I.5.3.4: Either both or none : */
789
if( return_indexed || !color.jp2_pclr->cmap) {
790
jp2_free_pclr(&color);
791
image->has_palette = OPJ_TRUE;
793
jp2_apply_pclr(&color, image, cinfo);
795
if(color.icc_profile_buf)
797
image->icc_profile_buf = color.icc_profile_buf;
798
color.icc_profile_buf = NULL;
799
image->icc_profile_len = color.icc_profile_len;
805
}/* opj_jp2_decode() */
808
void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
811
box.init_pos = cio_tell(cio);
813
cio_write(cio, JP2_JP2H, 4); /* JP2H */
815
jp2_write_ihdr(jp2, cio);
817
if (jp2->bpc == 255) {
818
jp2_write_bpcc(jp2, cio);
820
jp2_write_colr(jp2, cio);
822
box.length = cio_tell(cio) - box.init_pos;
823
cio_seek(cio, box.init_pos);
824
cio_write(cio, box.length, 4); /* L */
825
cio_seek(cio, box.init_pos + box.length);
828
static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
832
box.init_pos = cio_tell(cio);
834
cio_write(cio, JP2_FTYP, 4); /* FTYP */
836
cio_write(cio, jp2->brand, 4); /* BR */
837
cio_write(cio, jp2->minversion, 4); /* MinV */
839
for (i = 0; i < jp2->numcl; i++) {
840
cio_write(cio, jp2->cl[i], 4); /* CL */
843
box.length = cio_tell(cio) - box.init_pos;
844
cio_seek(cio, box.init_pos);
845
cio_write(cio, box.length, 4); /* L */
846
cio_seek(cio, box.init_pos + box.length);
849
static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
853
opj_common_ptr cinfo = jp2->cinfo;
855
jp2_read_boxhdr(cinfo, cio, &box);
857
if (JP2_FTYP != box.type) {
858
opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n");
862
jp2->brand = cio_read(cio, 4); /* BR */
863
jp2->minversion = cio_read(cio, 4); /* MinV */
864
jp2->numcl = (box.length - 16) / 4;
865
jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
867
for (i = 0; i < (int)jp2->numcl; i++) {
868
jp2->cl[i] = cio_read(cio, 4); /* CLi */
871
if (cio_tell(cio) - box.init_pos != box.length) {
872
opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n");
879
static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
880
unsigned int j2k_codestream_offset, j2k_codestream_length;
883
opj_j2k_t *j2k = jp2->j2k;
885
box.init_pos = cio_tell(cio);
887
cio_write(cio, JP2_JP2C, 4); /* JP2C */
890
j2k_codestream_offset = cio_tell(cio);
891
if(!j2k_encode(j2k, cio, image, cstr_info)) {
892
opj_event_msg(j2k->cinfo, EVT_ERROR, "Failed to encode image\n");
895
j2k_codestream_length = cio_tell(cio) - j2k_codestream_offset;
897
jp2->j2k_codestream_offset = j2k_codestream_offset;
898
jp2->j2k_codestream_length = j2k_codestream_length;
900
box.length = 8 + jp2->j2k_codestream_length;
901
cio_seek(cio, box.init_pos);
902
cio_write(cio, box.length, 4); /* L */
903
cio_seek(cio, box.init_pos + box.length);
908
static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset) {
911
opj_common_ptr cinfo = jp2->cinfo;
913
jp2_read_boxhdr(cinfo, cio, &box);
915
if(JP2_JP2C != box.type) {
916
cio_skip(cio, box.length - 8);
917
jp2_read_boxhdr(cinfo, cio, &box);
919
} while(JP2_JP2C != box.type);
921
*j2k_codestream_offset = cio_tell(cio);
922
*j2k_codestream_length = box.length - 8;
927
static void jp2_write_jp(opj_cio_t *cio) {
930
box.init_pos = cio_tell(cio);
932
cio_write(cio, JP2_JP, 4); /* JP2 signature */
933
cio_write(cio, 0x0d0a870a, 4);
935
box.length = cio_tell(cio) - box.init_pos;
936
cio_seek(cio, box.init_pos);
937
cio_write(cio, box.length, 4); /* L */
938
cio_seek(cio, box.init_pos + box.length);
941
static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) {
944
opj_common_ptr cinfo = jp2->cinfo;
946
jp2_read_boxhdr(cinfo, cio, &box);
947
if (JP2_JP != box.type) {
948
opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n");
951
if (0x0d0a870a != cio_read(cio, 4)) {
952
opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n");
955
if (cio_tell(cio) - box.init_pos != box.length) {
956
opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n");
964
static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
965
opj_jp2_color_t *color) {
966
if (!jp2_read_jp(jp2, cio))
968
if (!jp2_read_ftyp(jp2, cio))
970
if (!jp2_read_jp2h(jp2, cio, color))
972
if (!jp2_read_jp2c(jp2, cio, &jp2->j2k_codestream_length, &jp2->j2k_codestream_offset))
979
static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
983
lenp = cio_tell( cio);
984
cio_skip( cio, 4); /* L [at the end] */
985
cio_write( cio, JPIP_FIDX, 4); /* IPTR */
987
write_prxy( offset_jp2c, length_jp2c, offset_idx, length_idx, cio);
989
len = cio_tell( cio)-lenp;
990
cio_seek( cio, lenp);
991
cio_write( cio, len, 4); /* L */
992
cio_seek( cio, lenp+len);
997
static void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
1001
lenp = cio_tell( cio);
1002
cio_skip( cio, 4); /* L [at the end] */
1003
cio_write( cio, JPIP_PRXY, 4); /* IPTR */
1005
cio_write( cio, offset_jp2c, 8); /* OOFF */
1006
cio_write( cio, length_jp2c, 4); /* OBH part 1 */
1007
cio_write( cio, JP2_JP2C, 4); /* OBH part 2 */
1009
cio_write( cio, 1,1); /* NI */
1011
cio_write( cio, offset_idx, 8); /* IOFF */
1012
cio_write( cio, length_idx, 4); /* IBH part 1 */
1013
cio_write( cio, JPIP_CIDX, 4); /* IBH part 2 */
1015
len = cio_tell( cio)-lenp;
1016
cio_seek( cio, lenp);
1017
cio_write( cio, len, 4); /* L */
1018
cio_seek( cio, lenp+len);
1021
static void write_iptr( int offset, int length, opj_cio_t *cio)
1025
lenp = cio_tell( cio);
1026
cio_skip( cio, 4); /* L [at the end] */
1027
cio_write( cio, JPIP_IPTR, 4); /* IPTR */
1029
cio_write( cio, offset, 8);
1030
cio_write( cio, length, 8);
1032
len = cio_tell( cio)-lenp;
1033
cio_seek( cio, lenp);
1034
cio_write( cio, len, 4); /* L */
1035
cio_seek( cio, lenp+len);
1039
/* ----------------------------------------------------------------------- */
1040
/* JP2 decoder interface */
1041
/* ----------------------------------------------------------------------- */
1043
opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) {
1044
opj_jp2_t *jp2 = (opj_jp2_t*) opj_calloc(1, sizeof(opj_jp2_t));
1047
/* create the J2K codec */
1048
jp2->j2k = j2k_create_decompress(cinfo);
1049
if(jp2->j2k == NULL) {
1050
jp2_destroy_decompress(jp2);
1057
void jp2_destroy_decompress(opj_jp2_t *jp2) {
1059
/* destroy the J2K codec */
1060
j2k_destroy_decompress(jp2->j2k);
1063
opj_free(jp2->comps);
1072
void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) {
1073
/* setup the J2K codec */
1074
j2k_setup_decoder(jp2->j2k, parameters);
1075
/* further JP2 initializations go here */
1076
jp2->ignore_pclr_cmap_cdef = parameters->flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
1079
/* ----------------------------------------------------------------------- */
1080
/* JP2 encoder interface */
1081
/* ----------------------------------------------------------------------- */
1083
opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo) {
1084
opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
1087
/* create the J2K codec */
1088
jp2->j2k = j2k_create_compress(cinfo);
1089
if(jp2->j2k == NULL) {
1090
jp2_destroy_compress(jp2);
1097
void jp2_destroy_compress(opj_jp2_t *jp2) {
1099
/* destroy the J2K codec */
1100
j2k_destroy_compress(jp2->j2k);
1103
opj_free(jp2->comps);
1112
void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image) {
1116
if(!jp2 || !parameters || !image)
1119
/* setup the J2K codec */
1120
/* ------------------- */
1122
/* Check if number of components respects standard */
1123
if (image->numcomps < 1 || image->numcomps > 16384) {
1124
opj_event_msg(jp2->cinfo, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
1128
j2k_setup_encoder(jp2->j2k, parameters, image);
1130
/* setup the JP2 codec */
1131
/* ------------------- */
1135
jp2->brand = JP2_JP2; /* BR */
1136
jp2->minversion = 0; /* MinV */
1138
jp2->cl = (unsigned int*) opj_malloc(jp2->numcl * sizeof(unsigned int));
1139
jp2->cl[0] = JP2_JP2; /* CL0 : JP2 */
1141
/* Image Header box */
1143
jp2->numcomps = image->numcomps; /* NC */
1144
jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
1145
jp2->h = image->y1 - image->y0; /* HEIGHT */
1146
jp2->w = image->x1 - image->x0; /* WIDTH */
1148
depth_0 = image->comps[0].prec - 1;
1149
sign = image->comps[0].sgnd;
1150
jp2->bpc = depth_0 + (sign << 7);
1151
for (i = 1; i < image->numcomps; i++) {
1152
int depth = image->comps[i].prec - 1;
1153
sign = image->comps[i].sgnd;
1154
if (depth_0 != depth)
1157
jp2->C = 7; /* C : Always 7 */
1158
jp2->UnkC = 0; /* UnkC, colorspace specified in colr box */
1159
jp2->IPR = 0; /* IPR, no intellectual property */
1161
/* BitsPerComponent box */
1163
for (i = 0; i < image->numcomps; i++) {
1164
jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
1167
if (image->color_space == 1)
1168
jp2->enumcs = 16; /* sRGB as defined by IEC 61966-2.1 */
1169
else if (image->color_space == 2)
1170
jp2->enumcs = 17; /* greyscale */
1171
else if (image->color_space == 3)
1172
jp2->enumcs = 18; /* YUV */
1173
jp2->precedence = 0; /* PRECEDENCE */
1174
jp2->approx = 0; /* APPROX */
1176
jp2->jpip_on = parameters->jpip_on;
1179
opj_bool opj_jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
1181
int pos_iptr, pos_cidx, pos_jp2c, len_jp2c, len_cidx, end_pos, pos_fidx, len_fidx;
1182
pos_jp2c = pos_iptr = -1; /* remove a warning */
1186
/* JPEG 2000 Signature box */
1189
jp2_write_ftyp(jp2, cio);
1190
/* JP2 Header box */
1191
jp2_write_jp2h(jp2, cio);
1194
pos_iptr = cio_tell( cio);
1195
cio_skip( cio, 24); /* IPTR further ! */
1197
pos_jp2c = cio_tell( cio);
1201
if(!(len_jp2c = jp2_write_jp2c( jp2, cio, image, cstr_info))){
1202
opj_event_msg(jp2->cinfo, EVT_ERROR, "Failed to encode image\n");
1207
pos_cidx = cio_tell( cio);
1209
len_cidx = write_cidx( pos_jp2c+8, cio, image, *cstr_info, len_jp2c-8);
1211
pos_fidx = cio_tell( cio);
1212
len_fidx = write_fidx( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio);
1214
end_pos = cio_tell( cio);
1216
cio_seek( cio, pos_iptr);
1217
write_iptr( pos_fidx, len_fidx, cio);
1219
cio_seek( cio, end_pos);
added
removed
openjpeg/libopenjpeg/jp2.c
