2 * Copyright (c) 2001-2002, David Janssens
3 * Copyright (c) 2003-2004, Yannick Verschueren
4 * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
43 #define J2K_MS_SOC 0xff4f
44 #define J2K_MS_SOT 0xff90
45 #define J2K_MS_SOD 0xff93
46 #define J2K_MS_EOC 0xffd9
47 #define J2K_MS_SIZ 0xff51
48 #define J2K_MS_COD 0xff52
49 #define J2K_MS_COC 0xff53
50 #define J2K_MS_RGN 0xff5e
51 #define J2K_MS_QCD 0xff5c
52 #define J2K_MS_QCC 0xff5d
53 #define J2K_MS_POC 0xff5f
54 #define J2K_MS_TLM 0xff55
55 #define J2K_MS_PLM 0xff57
56 #define J2K_MS_PLT 0xff58
57 #define J2K_MS_PPM 0xff60
58 #define J2K_MS_PPT 0xff61
59 #define J2K_MS_SOP 0xff91
60 #define J2K_MS_EPH 0xff92
61 #define J2K_MS_CRG 0xff63
62 #define J2K_MS_COM 0xff64
64 #define J2K_STATE_MHSOC 0x0001
65 #define J2K_STATE_MHSIZ 0x0002
66 #define J2K_STATE_MH 0x0004
67 #define J2K_STATE_TPHSOT 0x0008
68 #define J2K_STATE_TPH 0x0010
69 #define J2K_STATE_MT 0x0020
77 static int j2k_curtileno;
78 static j2k_tcp_t j2k_default_tcp;
79 static unsigned char *j2k_eot;
81 static j2k_image_t *j2k_img;
82 static j2k_cp_t *j2k_cp;
84 static unsigned char **j2k_tile_data;
85 static int *j2k_tile_len;
87 static info_image_t img;
92 int compno=0, resno=0, precno=0;
94 tcd_free(j2k_img, j2k_cp);
95 for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {
96 info_tile_t *tile_Idx = &img.tile[tileno];
98 for (compno = 0; compno < img.Comp; compno++)
100 info_compo_t *compo_Idx = &tile_Idx->compo[compno];
101 for(resno = 0; resno < img.Decomposition + 1; resno++)
103 info_reso_t *reso_Idx = &compo_Idx->reso[resno];
104 for (precno = 0; precno < img.tile[tileno].pw * img.tile[tileno].ph; precno++)
106 info_prec_t *prec_Idx = &reso_Idx->prec[precno];
107 free(prec_Idx->layer);
109 free(reso_Idx->prec);
111 free(compo_Idx->reso);
113 free(tile_Idx->compo);
114 free(tile_Idx->marker);
115 free(tile_Idx->tile_parts);
116 free(tile_Idx->marker_mul.COC);
117 free(tile_Idx->marker_mul.RGN);
118 free(tile_Idx->marker_mul.QCC);
119 free(tile_Idx->marker_mul.PLT);
120 free(tile_Idx->marker_mul.PPT);
121 free(tile_Idx->marker_mul.COM);
125 free(img.marker_mul.COC);
126 free(img.marker_mul.RGN);
127 free(img.marker_mul.QCC);
128 free(img.marker_mul.PLM);
129 free(img.marker_mul.PPM);
130 free(img.marker_mul.COM);
135 void j2k_read_soc() {
136 j2k_state=J2K_STATE_MHSIZ;
141 void j2k_read_siz() {
147 /* <INDEX> [MHIX BOX] */
148 img.marker[img.num_marker].type = J2K_MS_SIZ;
149 img.marker[img.num_marker].start_pos = cio_tell()-2;
150 img.marker[img.num_marker].len = len;
152 /* </INDEX> [MHIX BOX] */
154 cio_read(2); /* Rsiz (capabilities) */
155 j2k_img->x1 = cio_read(4); /* Xsiz */
156 j2k_img->y1 = cio_read(4); /* Ysiz */
157 j2k_img->x0 = cio_read(4); /* X0siz */
158 j2k_img->y0 = cio_read(4); /* Y0siz */
159 j2k_cp->tdx = cio_read(4); /* XTsiz */
160 j2k_cp->tdy = cio_read(4); /* YTsiz */
161 j2k_cp->tx0 = cio_read(4); /* XT0siz */
162 j2k_cp->ty0 = cio_read(4); /* YTOsiz */
164 j2k_img->numcomps = cio_read(2); /* Csiz */
165 j2k_img->comps = (j2k_comp_t*)malloc(j2k_img->numcomps * sizeof(j2k_comp_t));
166 for (i = 0; i < j2k_img->numcomps; i++) {
169 j2k_img->comps[i].prec = (tmp & 0x7f) + 1;
170 j2k_img->comps[i].sgnd = tmp >> 7;
171 j2k_img->comps[i].dx = cio_read(1);
172 j2k_img->comps[i].dy = cio_read(1);
173 w = int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
174 h = int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
175 j2k_img->comps[i].data = (int*)malloc(sizeof(int) * w * h);
177 j2k_cp->tw = int_ceildiv(j2k_img->x1 - j2k_cp->tx0, j2k_cp->tdx);
178 j2k_cp->th = int_ceildiv(j2k_img->y1 - j2k_cp->ty0, j2k_cp->tdy);
180 j2k_cp->tcps = (j2k_tcp_t*)calloc((j2k_cp->tw * j2k_cp->th), sizeof(j2k_tcp_t));
182 for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++)
184 j2k_cp->tcps[i].POC = 0;
185 j2k_cp->tcps[i].numpocs = 0;
186 // j2k_cp->tcps[i].first=1;
189 /* Initialization for PPM marker */
191 j2k_cp->ppm_data = NULL;
192 j2k_cp->ppm_previous = 0;
193 j2k_cp->ppm_store = 0;
195 j2k_default_tcp.tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
196 for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {
197 j2k_cp->tcps[i].tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
199 j2k_tile_data = (unsigned char**)calloc(j2k_cp->tw * j2k_cp->th, sizeof(char*));
200 j2k_tile_len = (int*)calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));
201 j2k_state = J2K_STATE_MH;
204 img.Im_w = j2k_img->x1 - j2k_img->x0;
205 img.Im_h = j2k_img->y1 - j2k_img->y0;
206 img.Tile_x = j2k_cp->tdx;
207 img.Tile_y = j2k_cp->tdy;
208 img.Comp = j2k_img->numcomps;
211 img.tile = (info_tile_t*)malloc(img.tw * img.th * sizeof(info_tile_t));
213 for (i = 0; i < img.tw * img.th; i++)
216 tile->marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
217 tile->num_marker = 0;
218 tile->marker_mul.num_COC = 0;
219 tile->marker_mul.CzCOC = START_NB;
220 tile->marker_mul.num_RGN = 0;
221 tile->marker_mul.CzRGN = START_NB;
222 tile->marker_mul.num_QCC = 0;
223 tile->marker_mul.CzQCC = START_NB;
224 tile->marker_mul.num_PLT = 0;
225 tile->marker_mul.CzPLT = START_NB;
226 tile->marker_mul.num_PPT = 0;
227 tile->marker_mul.CzPPT = START_NB;
228 tile->marker_mul.num_COM = 0;
229 tile->marker_mul.CzCOM = START_NB;
236 void j2k_read_com() {
243 /* <INDEX> [MHIX BOX] */
244 if (j2k_state == J2K_STATE_MH)
246 if (!img.marker_mul.num_COM)
247 img.marker_mul.COM = (info_marker_t*)malloc(img.marker_mul.CzCOM * sizeof(info_marker_t));
248 if (img.marker_mul.num_COM >= img.marker_mul.CzCOM)
250 tmp = (info_marker_t*)malloc(2 * img.marker_mul.CzCOM * sizeof(info_marker_t));
251 memcpy(tmp,img.marker_mul.COM,img.marker_mul.CzCOM);
252 img.marker_mul.CzCOM *= 2;
253 free(img.marker_mul.COM);
254 img.marker_mul.COM = tmp;
257 img.marker_mul.COM[img.marker_mul.num_COM].type = J2K_MS_COM;
258 img.marker_mul.COM[img.marker_mul.num_COM].start_pos = cio_tell()-2;
259 img.marker_mul.COM[img.marker_mul.num_COM].len = len;
260 img.marker_mul.num_COM++;
263 tile = &img.tile[j2k_curtileno];
264 if (!tile->marker_mul.num_COM)
265 tile->marker_mul.COM = (info_marker_t*)calloc(START_NB, sizeof(info_marker_t));
266 if (tile->marker_mul.num_COM >= tile->marker_mul.CzCOM)
268 tmp = (info_marker_t*)malloc(2 * tile->marker_mul.CzCOM * sizeof(info_marker_t));
269 memcpy(tmp,tile->marker_mul.COM,tile->marker_mul.CzCOM);
270 tile->marker_mul.CzCOM *= 2;
271 free(tile->marker_mul.COM);
272 tile->marker_mul.COM = tmp;
274 tile->marker_mul.COM[tile->marker_mul.num_COM].type = J2K_MS_COM;
275 tile->marker_mul.COM[tile->marker_mul.num_COM].start_pos = cio_tell()-2;
276 tile->marker_mul.COM[tile->marker_mul.num_COM].len = len;
277 tile->marker_mul.num_COM++;
279 /* </INDEX> [MHIX BOX] */
287 void j2k_read_cox(int compno) {
292 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
293 tccp = &tcp->tccps[compno];
294 tccp->numresolutions = cio_read(1) + 1;
296 img.Decomposition = tccp->numresolutions - 1; /* <INDEX> */
298 tccp->cblkw = cio_read(1) + 2;
299 tccp->cblkh = cio_read(1) + 2;
300 tccp->cblksty = cio_read(1);
301 tccp->qmfbid = cio_read(1);
302 if (tccp->csty&J2K_CP_CSTY_PRT) {
303 for (i = 0; i < tccp->numresolutions; i++) {
304 int tmp = cio_read(1);
305 tccp->prcw[i] = tmp&0xf;
306 tccp->prch[i] = tmp>>4;
314 void j2k_read_cod() {
319 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
322 /* <INDEX> [MHIX BOX] */
323 if (j2k_state == J2K_STATE_MH)
325 img.marker[img.num_marker].type = J2K_MS_SIZ;
326 img.marker[img.num_marker].start_pos = cio_tell()-2;
327 img.marker[img.num_marker].len = len;
332 tile = &img.tile[j2k_curtileno];
333 tile->marker[tile->num_marker].type = J2K_MS_SIZ;
334 tile->marker[tile->num_marker].start_pos = cio_tell()-2;
335 tile->marker[tile->num_marker].len = len;
338 /* </INDEX> [MHIX BOX] */
340 tcp->csty = cio_read(1);
341 tcp->prg = cio_read(1);
342 tcp->numlayers = cio_read(2);
343 tcp->mct = cio_read(1);
346 for (i = 0; i < j2k_img->numcomps; i++) {
347 tcp->tccps[i].csty = tcp->csty&J2K_CP_CSTY_PRT;
354 img.Layer = tcp->numlayers;
361 void j2k_read_coc() {
367 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
370 /* <INDEX> [MHIX BOX] */
371 if (j2k_state == J2K_STATE_MH)
373 if (!img.marker_mul.num_COC)
374 img.marker_mul.COC = (info_marker_t*)malloc(img.marker_mul.CzCOC * sizeof(info_marker_t));
375 if (img.marker_mul.num_COC >= img.marker_mul.CzCOC)
377 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzCOC) * sizeof(info_marker_t));
378 memcpy(tmp,img.marker_mul.COC,img.marker_mul.CzCOC);
379 img.marker_mul.CzCOC += INCREMENT;
380 free(img.marker_mul.COC);
381 img.marker_mul.COC = tmp;
383 img.marker_mul.COC[img.marker_mul.num_COC].type = J2K_MS_COC;
384 img.marker_mul.COC[img.marker_mul.num_COC].start_pos = cio_tell()-2;
385 img.marker_mul.COC[img.marker_mul.num_COC].len = len;
386 img.marker_mul.num_COC++;
389 tile = &img.tile[j2k_curtileno];
390 if (!tile->marker_mul.num_COC)
391 tile->marker_mul.COC = (info_marker_t*)malloc(tile->marker_mul.CzCOC * sizeof(info_marker_t));
392 if (tile->marker_mul.num_COC >= tile->marker_mul.CzCOC)
394 tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzCOC) * sizeof(info_marker_t));
395 memcpy(tmp,tile->marker_mul.COC,tile->marker_mul.CzCOC);
396 tile->marker_mul.CzCOC += INCREMENT;
397 free(tile->marker_mul.COC);
398 tile->marker_mul.COC = tmp;
400 tile->marker_mul.COC[tile->marker_mul.num_COC].type = J2K_MS_COC;
401 tile->marker_mul.COC[tile->marker_mul.num_COC].start_pos = cio_tell() - 2;
402 tile->marker_mul.COC[tile->marker_mul.num_COC].len = len;
403 tile->marker_mul.num_COC++;
405 /* </INDEX> [MHIX BOX] */
407 compno =cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
409 tcp->tccps[compno].csty = cio_read(1);
410 j2k_read_cox(compno);
416 void j2k_read_qcx(int compno, int len) {
420 int bandno, numbands;
422 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
423 tccp = &tcp->tccps[compno];
425 tccp->qntsty = tmp & 0x1f;
426 tccp->numgbits = tmp >> 5;
427 numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT ? len - 1 : (len - 1) / 2);
428 for (bandno = 0; bandno < numbands; bandno++) {
430 if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) { /* WHY STEPSIZES WHEN NOQNT ? */
431 expn = cio_read(1) >> 3;
438 tccp->stepsizes[bandno].expn = expn;
439 tccp->stepsizes[bandno].mant = mant;
446 void j2k_read_qcd() {
452 /* <INDEX> [MHIX BOX] */
453 if (j2k_state == J2K_STATE_MH)
455 img.marker[img.num_marker].type = J2K_MS_QCD;
456 img.marker[img.num_marker].start_pos = cio_tell()-2;
457 img.marker[img.num_marker].len = len;
461 tile = &img.tile[j2k_curtileno];
462 tile->marker[tile->num_marker].type = J2K_MS_QCD;
463 tile->marker[tile->num_marker].start_pos = cio_tell()-2;
464 tile->marker[tile->num_marker].len = len;
467 /* </INDEX> [MHIX BOX] */
471 for (i = 0; i < j2k_img->numcomps; i++) {
473 j2k_read_qcx(i, len - 2);
480 void j2k_read_qcc() {
486 /* <INDEX> [MHIX BOX] */
487 if (j2k_state == J2K_STATE_MH)
489 if (!img.marker_mul.num_QCC)
490 img.marker_mul.QCC = (info_marker_t*)malloc(img.marker_mul.CzQCC * sizeof(info_marker_t));
491 if (img.marker_mul.num_QCC >= img.marker_mul.CzQCC)
493 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzQCC) * sizeof(info_marker_t));
494 memcpy(tmp,img.marker_mul.QCC,img.marker_mul.CzQCC);
495 img.marker_mul.CzQCC += INCREMENT;
496 free(img.marker_mul.QCC);
497 img.marker_mul.QCC = tmp;
499 img.marker_mul.QCC[img.marker_mul.num_QCC].type = J2K_MS_QCC;
500 img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos = cio_tell() - 2;
501 img.marker_mul.QCC[img.marker_mul.num_QCC].len = len;
502 img.marker_mul.num_QCC++;
505 tile = &img.tile[j2k_curtileno];
506 if (!tile->marker_mul.num_QCC)
507 tile->marker_mul.QCC = (info_marker_t*)malloc(tile->marker_mul.CzQCC * sizeof(info_marker_t));
508 if (tile->marker_mul.num_QCC >= tile->marker_mul.CzQCC)
510 tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzQCC) * sizeof(info_marker_t));
511 memcpy(tmp,tile->marker_mul.QCC,tile->marker_mul.CzQCC);
512 tile->marker_mul.CzQCC += INCREMENT;
513 free(tile->marker_mul.QCC);
514 tile->marker_mul.QCC = tmp;
516 tile->marker_mul.QCC[tile->marker_mul.num_QCC].type = J2K_MS_QCC;
517 tile->marker_mul.QCC[tile->marker_mul.num_QCC].start_pos = cio_tell()-2;
518 tile->marker_mul.QCC[tile->marker_mul.num_QCC].len = len;
519 tile->marker_mul.num_QCC++;
521 /* </INDEX> [MHIX BOX] */
523 compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
524 j2k_read_qcx(compno, len - 2 - (j2k_img->numcomps <= 256 ? 1 : 2));
530 void j2k_read_poc() {
531 int len, numpchgs, i, old_poc;
536 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
537 old_poc = tcp->POC ? tcp->numpocs+1 : 0;
539 tccp = &tcp->tccps[0];
542 /* <INDEX> [MHIX BOX] */
543 if (j2k_state == J2K_STATE_MH)
545 img.marker[img.num_marker].type = J2K_MS_POC;
546 img.marker[img.num_marker].start_pos = cio_tell()-2;
547 img.marker[img.num_marker].len = len;
551 tile = &img.tile[j2k_curtileno];
552 tile->marker[tile->num_marker].type = J2K_MS_POC;
553 tile->marker[tile->num_marker].start_pos = cio_tell()-2;
554 tile->marker[tile->num_marker].len = len;
557 /* </INDEX> [MHIX BOX] */
559 numpchgs = (len - 2) / (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2));
560 for (i = 0; i < numpchgs; i++) {
563 poc->resno0 = cio_read(1);
564 poc->compno0 = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
565 poc->layno1 = int_min(cio_read(2), tcp->numlayers);
566 poc->resno1 = int_min(cio_read(1), tccp->numresolutions);
567 poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps);
568 poc->prg = cio_read(1);
571 tcp->numpocs = numpchgs + old_poc - 1;
577 void j2k_read_crg() {
578 int len, i, Xcrg_i, Ycrg_i;
582 /* <INDEX> [MHIX BOX] */
583 img.marker[img.num_marker].type = J2K_MS_CRG;
584 img.marker[img.num_marker].start_pos = cio_tell()-2;
585 img.marker[img.num_marker].len = len;
587 /* </INDEX> [MHIX BOX] */
589 for (i = 0; i < j2k_img->numcomps; i++)
591 Xcrg_i = cio_read(2);
592 Ycrg_i = cio_read(2);
599 void j2k_read_tlm() {
600 int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
601 long int Ttlm_i, Ptlm_i;
606 /* <INDEX> [MHIX BOX] */
607 if (!img.marker_mul.num_TLM)
608 img.marker_mul.TLM = (info_marker_t*)malloc(img.marker_mul.CzTLM * sizeof(info_marker_t));
609 if (img.marker_mul.num_TLM >= img.marker_mul.CzTLM)
611 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzTLM) * sizeof(info_marker_t));
612 memcpy(tmp,img.marker_mul.TLM,img.marker_mul.CzTLM);
613 img.marker_mul.CzTLM += INCREMENT;
614 free(img.marker_mul.TLM);
615 img.marker_mul.TLM = tmp;
617 img.marker_mul.TLM[img.marker_mul.num_TLM].type = J2K_MS_TLM;
618 img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos = cio_tell()-2;
619 img.marker_mul.TLM[img.marker_mul.num_TLM].len = len;
620 img.marker_mul.num_TLM++;
621 /* </INDEX> [MHIX BOX] */
625 ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
626 SP = (Stlm >> 6) & 0x01;
627 tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
628 for (i = 0; i < tile_tlm; i++)
630 Ttlm_i = cio_read(ST);
631 Ptlm_i = cio_read(SP ? 4 : 2);
638 void j2k_read_plm() {
639 int len, i, Z_plm, N_plm, add, packet_len=0;
644 /* <INDEX> [MHIX BOX] */
645 if (!img.marker_mul.num_PLM)
646 img.marker_mul.PLM = (info_marker_t*)malloc(img.marker_mul.CzPLM * sizeof(info_marker_t));
647 if (img.marker_mul.num_PLM >= img.marker_mul.CzPLM)
649 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPLM) * sizeof(info_marker_t));
650 memcpy(tmp,img.marker_mul.PLM,img.marker_mul.CzPLM);
651 img.marker_mul.CzPLM += INCREMENT;
652 free(img.marker_mul.PLM);
653 img.marker_mul.PLM = tmp;
655 img.marker_mul.PLM[img.marker_mul.num_PLM].type = J2K_MS_PLM;
656 img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos = cio_tell()-2;
657 img.marker_mul.PLM[img.marker_mul.num_PLM].len = len;
658 img.marker_mul.num_PLM++;
659 /* </INDEX> [MHIX BOX] */
667 for (i = N_plm ; i > 0 ; i--)
671 packet_len = (packet_len << 7) + add;
672 if ((add & 0x80) == 0)
685 void j2k_read_plt() {
686 int len, i, Zplt, packet_len=0, add;
692 /* <INDEX> [MHIX BOX] */
693 tile = &img.tile[j2k_curtileno];
694 if (!tile->marker_mul.num_PLT)
695 tile->marker_mul.PLT = (info_marker_t*)malloc(tile->marker_mul.CzPLT * sizeof(info_marker_t));
696 if (tile->marker_mul.num_PLT >= tile->marker_mul.CzPLT)
698 tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzPLT) * sizeof(info_marker_t));
699 memcpy(tmp,tile->marker_mul.PLT,tile->marker_mul.CzPLT);
700 tile->marker_mul.CzPLT += INCREMENT;
701 free(tile->marker_mul.PLT);
702 tile->marker_mul.PLT = tmp;
705 tile->marker_mul.PLT[tile->marker_mul.num_PLT].type = J2K_MS_PLT;
706 tile->marker_mul.PLT[tile->marker_mul.num_PLT].start_pos = cio_tell()-2;
707 tile->marker_mul.PLT[tile->marker_mul.num_PLT].len = len;
708 tile->marker_mul.num_PLT++;
709 /* </INDEX> [MHIX BOX] */
712 for (i = len-3; i > 0; i--)
715 packet_len = (packet_len << 7) + add;
716 if ((add & 0x80) == 0)
727 void j2k_read_ppm() {
728 int len, Z_ppm, i, j;
734 /* <INDEX> [MHIX BOX] */
735 if (!img.marker_mul.num_PPM)
736 img.marker_mul.PPM = (info_marker_t*)malloc(img.marker_mul.CzPPM * sizeof(info_marker_t));
737 if (img.marker_mul.num_PPM >= img.marker_mul.CzPPM)
739 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPPM) * sizeof(info_marker_t));
740 memcpy(tmp,img.marker_mul.PPM,img.marker_mul.CzPPM);
741 img.marker_mul.CzPPM += INCREMENT;
742 free(img.marker_mul.PPM);
743 img.marker_mul.PPM = tmp;
745 img.marker_mul.PLM[img.marker_mul.num_PPM].type = J2K_MS_PPM;
746 img.marker_mul.PLM[img.marker_mul.num_PPM].start_pos = cio_tell()-2;
747 img.marker_mul.PLM[img.marker_mul.num_PPM].len = len;
748 img.marker_mul.num_PPM++;
749 /* </INDEX> [MHIX BOX] */
753 Z_ppm = cio_read(1); /* Z_ppm */
757 if (j2k_cp->ppm_previous == 0)
759 N_ppm = cio_read(4); /* N_ppm */
763 N_ppm = j2k_cp->ppm_previous;
766 j = j2k_cp->ppm_store;
767 if (Z_ppm == 0) /* First PPM marker */
768 j2k_cp->ppm_data = (unsigned char*)calloc(N_ppm, sizeof(unsigned char));
769 else /* NON-first PPM marker */
770 j2k_cp->ppm_data = (unsigned char*)realloc(j2k_cp->ppm_data, (N_ppm + j2k_cp->ppm_store) * sizeof(unsigned char));
772 for (i = N_ppm ; i > 0 ; i--) /* Read packet header */
774 j2k_cp->ppm_data[j] = cio_read(1);
777 if (len == 0) break; /* Case of non-finished packet header in present marker but finished in next one */
780 j2k_cp->ppm_previous = i - 1;
781 j2k_cp->ppm_store = j;
788 void j2k_read_ppt() {
789 int len, Z_ppt, i, j = 0;
794 /* <INDEX> [MHIX BOX] */
795 tile = & img.tile[j2k_curtileno];
796 tile->marker[tile->num_marker].type = J2K_MS_PPT;
797 tile->marker[tile->num_marker].start_pos = cio_tell()-2;
798 tile->marker[tile->num_marker].len = len;
800 /* </INDEX> [MHIX BOX] */
803 tcp = &j2k_cp->tcps[j2k_curtileno];
805 if (Z_ppt == 0) /* First PPT marker */
807 tcp->ppt_data = (unsigned char*)calloc(len - 3, sizeof(unsigned char));
810 else /* NON-first PPT marker */
811 tcp->ppt_data = (unsigned char*)realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
814 for (i = len - 3 ; i > 0 ; i--)
816 tcp->ppt_data[j] = cio_read(1);
825 void j2k_read_sot() {
826 int len, tileno, totlen, partno, numparts, i;
830 info_tile_part_t *tilepart_tmp;
833 //fprintf(stderr,"SOT\n");
835 tileno = cio_read(2);
836 /* <INDEX> [MHIX BOX] */
837 tile = & img.tile[tileno];
838 tile->marker[tile->num_marker].type = J2K_MS_SOT;
839 tile->marker[tile->num_marker].start_pos = cio_tell() - 4;
840 tile->marker[tile->num_marker].len = len;
842 /* </INDEX> [MHIX BOX] */
844 totlen = cio_read(4);
845 if (!totlen) totlen = cio_numbytesleft() + 8;
846 partno = cio_read(1);
847 numparts = cio_read(1);
850 if (tileno == 0 && partno == 0 )
851 img.Main_head_end = cio_tell() - 7; /* Correction End = First byte of first SOT */
853 img.tile[tileno].num_tile = tileno;
856 tile->numparts = partno + 1; /* INDEX : Number of tile_parts for the tile */
857 img.num_max_tile_parts = int_max(tile->numparts, img.num_max_tile_parts); /* INDEX : Maximum number of tile_part per tile */
861 tile->tile_parts = (info_tile_part_t*)malloc(START_NB * sizeof(info_tile_part_t*));
862 tile->Cztile_parts = START_NB;
864 if (partno >= tile->Cztile_parts)
866 tilepart_tmp = (info_tile_part_t*)malloc((INCREMENT + tile->Cztile_parts) * sizeof(info_tile_part_t));
867 memcpy(tmp, tile->tile_parts, tile->Cztile_parts);
868 tile->Cztile_parts += INCREMENT;
869 free(tile->tile_parts);
870 tile->tile_parts = tilepart_tmp;
873 tile->tile_parts[partno].start_pos = cio_tell() - 12; /* INDEX : start_pos of the tile_part */
874 tile->tile_parts[partno].length = totlen; /* INDEX : length of the tile_part */
875 tile->tile_parts[partno].end_pos = totlen + cio_tell() - 12; /* INDEX : end position of the tile_part */
878 j2k_curtileno = tileno;
879 j2k_eot = cio_getbp() - 12 + totlen;
880 j2k_state = J2K_STATE_TPH;
881 tcp = &j2k_cp->tcps[j2k_curtileno];
883 tile->tile_parts[numparts].num_reso_AUX = tcp->tccps[0].numresolutions; /* INDEX : AUX value for TPIX */
886 // if (tcp->first == 1)
889 *tcp = j2k_default_tcp;
890 /* Initialization PPT */
892 tcp->ppt_data = NULL;
895 for (i = 0; i < j2k_img->numcomps; i++) {
896 tcp->tccps[i] = j2k_default_tcp.tccps[i];
898 //j2k_cp->tcps[j2k_curtileno].first=0;
904 void j2k_read_rgn() {
905 int len, compno, roisty;
909 // fprintf(stderr,"RGN\n");
910 tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
913 /* <INDEX> [MHIX BOX]*/
914 if (j2k_state == J2K_STATE_MH)
916 if (!img.marker_mul.num_RGN)
917 img.marker_mul.RGN = (info_marker_t*)malloc(img.marker_mul.CzRGN * sizeof(info_marker_t));
918 if (img.marker_mul.num_RGN >= img.marker_mul.CzRGN)
920 tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzRGN) * sizeof(info_marker_t));
921 memcpy(tmp,img.marker_mul.RGN, img.marker_mul.CzRGN);
922 img.marker_mul.CzRGN += INCREMENT;
923 free(img.marker_mul.RGN);
924 img.marker_mul.RGN = tmp;
926 img.marker_mul.RGN[img.marker_mul.num_RGN].type = J2K_MS_RGN;
927 img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos = cio_tell() - 2;
928 img.marker_mul.RGN[img.marker_mul.num_RGN].len = len;
929 img.marker_mul.num_RGN++;
932 tile = &img.tile[j2k_curtileno];
933 if (!tile->marker_mul.num_RGN)
934 tile->marker_mul.RGN = (info_marker_t*)malloc(tile->marker_mul.CzRGN * sizeof(info_marker_t));
935 if (tile->marker_mul.num_RGN >= tile->marker_mul.CzRGN)
937 tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzRGN) * sizeof(info_marker_t));
938 memcpy(tmp,tile->marker_mul.RGN,tile->marker_mul.CzRGN);
939 tile->marker_mul.CzRGN += INCREMENT;
940 free(tile->marker_mul.RGN);
941 tile->marker_mul.RGN = tmp;
944 tile->marker_mul.RGN[tile->marker_mul.num_RGN].type = J2K_MS_RGN;
945 tile->marker_mul.RGN[tile->marker_mul.num_RGN].start_pos = cio_tell() - 2;
946 tile->marker_mul.RGN[tile->marker_mul.num_RGN].len = len;
947 tile->marker_mul.num_RGN++;
949 /* </INDEX> [MHIX BOX] */
951 compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
952 roisty = cio_read(1);
953 tcp->tccps[compno].roishift = cio_read(1);
960 void j2k_read_sod() {
964 info_tile_part_t *tile_part;
965 // fprintf(stderr,"SOD\n");
966 /* <INDEX> [MHIX BOX] */
967 tile = &img.tile[j2k_curtileno];
968 tile->marker[tile->num_marker].type = J2K_MS_SOD;
969 tile->marker[tile->num_marker].start_pos = cio_tell();
970 tile->marker[tile->num_marker].len = 0;
972 /* </INDEX> [MHIX BOX] */
974 tile_part = &tile->tile_parts[tile->numparts - 1]; /* INDEX : Current tilepart of a tile */
975 tile_part->length_header = cio_tell() - 1 - tile_part->start_pos; /* INDEX : length of the tile-part header */
976 tile_part->end_header = cio_tell() - 1; /* INDEX : end header position of the tile-part header */
978 len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft());
980 j2k_tile_len[j2k_curtileno] += len;
981 data = (unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
982 memcpy(data, cio_getbp(), len);
983 j2k_tile_data[j2k_curtileno] = data;
985 j2k_state = J2K_STATE_TPHSOT;
988 void j2k_read_eoc() {
990 tcd_init(j2k_img, j2k_cp, &img);
991 for (tileno = 0; tileno<j2k_cp->tw * j2k_cp->th; tileno++) {
992 tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno, &img);
995 j2k_state = J2K_STATE_MT;
996 longjmp(j2k_error, 1);
1002 void j2k_read_unk() {
1003 fprintf(stderr, "warning: unknown marker\n");
1009 int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len, int version){
1012 int pos_iptr, end_pos;
1013 int len_cidx, pos_cidx;
1014 int len_jp2c, pos_jp2c;
1015 int len_fidx, pos_fidx;
1017 dest=fopen(Idx_file, "wb");
1019 fprintf(stderr, "Failed to open %s for reading !!\n", Idx_file);
1023 /* INDEX MODE JPIP */
1024 index = (char*)malloc(len);
1025 cio_init(index, len);
1029 jp2_write_jp2h(j2k_img);
1030 jp2_write_dbtl(Idx_file);
1032 pos_iptr=cio_tell();
1033 cio_skip(24); /* IPTR further ! */
1035 pos_jp2c = cio_tell();
1036 len_jp2c = jp2_write_jp2c(J2K_file);
1038 pos_cidx = cio_tell();
1039 len_cidx = jpip_write_cidx(pos_jp2c + 8,img, j2k_cp, version); /* Correction len_jp2C --> pos_jp2c + 8 */
1042 pos_fidx = cio_tell();
1043 len_fidx = jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
1045 end_pos = cio_tell();
1048 jpip_write_iptr(pos_fidx,len_fidx);
1051 fwrite(index, 1, cio_tell(), dest);
1064 } j2k_dec_mstabent_t;
1066 j2k_dec_mstabent_t j2k_dec_mstab[]={
1067 {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
1068 {J2K_MS_SOT, J2K_STATE_MH|J2K_STATE_TPHSOT, j2k_read_sot},
1069 {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
1070 {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
1071 {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
1072 {J2K_MS_COD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_cod},
1073 {J2K_MS_COC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_coc},
1074 {J2K_MS_RGN, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_rgn},
1075 {J2K_MS_QCD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcd},
1076 {J2K_MS_QCC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcc},
1077 {J2K_MS_POC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_poc},
1078 {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
1079 {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
1080 {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
1081 {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
1082 {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
1084 {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
1085 {J2K_MS_COM, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_com},
1086 {0, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_unk}
1089 j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
1090 j2k_dec_mstabent_t *e;
1091 for (e = j2k_dec_mstab; e->id != 0; e++) {
1099 int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
1100 if (setjmp(j2k_error)) {
1101 if (j2k_state != J2K_STATE_MT) {
1102 fprintf(stderr, "WARNING: incomplete bitstream\n");
1105 return cio_numbytes();
1107 j2k_img = (j2k_image_t*)calloc(1, sizeof(j2k_image_t));
1108 j2k_cp = (j2k_cp_t*)calloc(1, sizeof(j2k_cp_t));
1111 j2k_state = J2K_STATE_MHSOC;
1114 j2k_dec_mstabent_t *e;
1115 int id = cio_read(2);
1116 if (id >> 8 != 0xff) {
1117 fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell() - 2, id);
1120 e = j2k_dec_mstab_lookup(id);
1121 if (!(j2k_state & e->states)) {
1122 fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1134 #include <windows.h>
1136 BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
1137 switch (ul_reason_for_call) {
1138 case DLL_PROCESS_ATTACH:
1139 case DLL_THREAD_ATTACH:
1140 case DLL_THREAD_DETACH:
1141 case DLL_PROCESS_DETACH:
1148 int main(int argc, char **argv)
1159 fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file version\n\nVersion : 0, 1, 2 or 3\n\n");
1163 src=fopen(argv[1], "rb");
1165 fprintf(stderr, "Failed to open %s for reading !!\n", argv[1]);
1169 /* length of the codestream */
1170 fseek(src, 0, SEEK_END);
1171 totlen = ftell(src);
1172 fseek(src, 0, SEEK_SET);
1174 j2kfile = (char*)malloc(totlen);
1175 fread(j2kfile, 1, totlen, src);
1178 img.marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
1180 img.num_max_tile_parts = 0;
1181 img.marker_mul.num_COC = 0;
1182 img.marker_mul.CzCOC = START_NB;
1183 img.marker_mul.num_RGN = 0;
1184 img.marker_mul.CzRGN = START_NB;
1185 img.marker_mul.num_QCC = 0;
1186 img.marker_mul.CzQCC = START_NB;
1187 img.marker_mul.num_TLM = 0;
1188 img.marker_mul.CzTLM = START_NB;
1189 img.marker_mul.num_PLM = 0;
1190 img.marker_mul.CzPLM = START_NB;
1191 img.marker_mul.num_PPM = 0;
1192 img.marker_mul.CzPPM = START_NB;
1193 img.marker_mul.num_COM = 0;
1194 img.marker_mul.CzCOM = START_NB;
1198 if (!j2k_decode(j2kfile, totlen, &imgg, &cp)) {
1199 fprintf(stderr, "Index_creator: failed to decode image!\n");
1204 // fseek(src, 0, SEEK_SET);
1205 img.codestream_size = totlen;
1206 sscanf(argv[3], "%d", &version);
1209 fprintf(stderr,"Error : value of version unauthorized !! Value accepted : 0, 1, 2 or 3 !!\n");
1213 j2k_index_JPIP(argv[2], argv[1], totlen * 2 > 60000 ? totlen * 2 : 60000, version);