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