2 * Copyright (c) 2001-2002, David Janssens
3 * Copyright (c) 2003, Yannick Verschueren
4 * Copyright (c) 2003, 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.
44 #define J2K_MS_SOC 0xff4f
45 #define J2K_MS_SOT 0xff90
46 #define J2K_MS_SOD 0xff93
47 #define J2K_MS_EOC 0xffd9
48 #define J2K_MS_SIZ 0xff51
49 #define J2K_MS_COD 0xff52
50 #define J2K_MS_COC 0xff53
51 #define J2K_MS_RGN 0xff5e
52 #define J2K_MS_QCD 0xff5c
53 #define J2K_MS_QCC 0xff5d
54 #define J2K_MS_POC 0xff5f
55 #define J2K_MS_TLM 0xff55
56 #define J2K_MS_PLM 0xff57
57 #define J2K_MS_PLT 0xff58
58 #define J2K_MS_PPM 0xff60
59 #define J2K_MS_PPT 0xff61
60 #define J2K_MS_SOP 0xff91
61 #define J2K_MS_EPH 0xff92
62 #define J2K_MS_CRG 0xff63
63 #define J2K_MS_COM 0xff64
65 #define J2K_STATE_MHSOC 0x0001
66 #define J2K_STATE_MHSIZ 0x0002
67 #define J2K_STATE_MH 0x0004
68 #define J2K_STATE_TPHSOT 0x0008
69 #define J2K_STATE_TPH 0x0010
70 #define J2K_STATE_MT 0x0020
75 static int j2k_curtileno;
76 static j2k_tcp_t j2k_default_tcp;
77 static unsigned char *j2k_eot;
79 static j2k_image_t *j2k_img;
80 static j2k_cp_t *j2k_cp;
82 static unsigned char **j2k_tile_data;
83 static int *j2k_tile_len;
85 static info_image_t img;
89 int compno, resno, precno;
91 tcd_free(j2k_img,j2k_cp);
93 for (tileno=0;tileno<j2k_cp->tw*j2k_cp->th;tileno++) {
94 info_tile_t *tile_Idx = &img.tile[tileno];
96 for (compno=0;compno<img.Comp;compno++)
98 info_compo_t *compo_Idx = &tile_Idx->compo[compno];
100 for(resno=0;resno<img.Decomposition+1;resno++)
102 info_reso_t *reso_Idx = &compo_Idx->reso[resno];
103 for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
105 info_prec_t *prec_Idx = &reso_Idx->prec[precno];
106 free(prec_Idx->layer);
108 free(reso_Idx->prec);
110 free(compo_Idx->reso);
112 free(tile_Idx->compo);
118 void j2k_read_soc() {
119 j2k_state=J2K_STATE_MHSIZ;
122 void j2k_read_siz() {
127 img.marker[img.num_marker].type=J2K_MS_SIZ;
128 img.marker[img.num_marker].start_pos=cio_tell()-2;
129 img.marker[img.num_marker].len=len;
134 cio_read(2); // Rsiz (capabilities)
135 j2k_img->x1=cio_read(4); // Xsiz
136 j2k_img->y1=cio_read(4); // Ysiz
137 j2k_img->x0=cio_read(4); // X0siz
138 j2k_img->y0=cio_read(4); // Y0siz
139 j2k_cp->tdx=cio_read(4); // XTsiz
140 j2k_cp->tdy=cio_read(4); // YTsiz
141 j2k_cp->tx0=cio_read(4); // XT0siz
142 j2k_cp->ty0=cio_read(4); // YTOsiz
143 j2k_img->numcomps=cio_read(2); // Csiz
144 j2k_img->comps=(j2k_comp_t*)malloc(j2k_img->numcomps*sizeof(j2k_comp_t));
145 for (i=0; i<j2k_img->numcomps; i++) {
148 j2k_img->comps[i].prec=(tmp&0x7f)+1;
149 j2k_img->comps[i].sgnd=tmp>>7;
150 j2k_img->comps[i].dx=cio_read(1);
151 j2k_img->comps[i].dy=cio_read(1);
152 w=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
153 h=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
154 j2k_img->comps[i].data=(int*)malloc(sizeof(int)*w*h);
156 j2k_cp->tw=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_cp->tdx);
157 j2k_cp->th=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_cp->tdy);
159 j2k_cp->tcps=(j2k_tcp_t*)calloc(sizeof(j2k_tcp_t), j2k_cp->tw*j2k_cp->th);
160 j2k_default_tcp.tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
161 for (i=0; i<j2k_cp->tw*j2k_cp->th; i++) {
162 j2k_cp->tcps[i].tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
164 j2k_tile_data=(unsigned char**)calloc(j2k_cp->tw*j2k_cp->th, sizeof(char*));
165 j2k_tile_len=(int*)calloc(j2k_cp->tw*j2k_cp->th, sizeof(int));
166 j2k_state=J2K_STATE_MH;
169 img.Im_w=j2k_img->x1-j2k_img->x0;
170 img.Im_h=j2k_img->y1-j2k_img->y0;
171 img.Tile_x=j2k_cp->tdx;
172 img.Tile_y=j2k_cp->tdy;
173 img.Comp=j2k_img->numcomps;
176 img.tile=(info_tile_t*)malloc((img.tw*img.th)*sizeof(info_tile_t));
182 void j2k_read_com() {
187 if (j2k_state==J2K_STATE_MH)
189 if (!img.marker_mul.num_COM)
190 img.marker_mul.COM=(info_marker_t*)malloc(sizeof(info_marker_t));
192 img.marker_mul.COM=realloc(img.marker_mul.COM,(1+img.marker_mul.num_COM)*sizeof(info_marker_t));
193 img.marker_mul.COM[img.marker_mul.num_COM].type=J2K_MS_COM;
194 img.marker_mul.COM[img.marker_mul.num_COM].start_pos=cio_tell()-2;
195 img.marker_mul.COM[img.marker_mul.num_COM].len=len;
196 img.marker_mul.num_COM++;
203 void j2k_read_cox(int compno) {
207 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
208 tccp=&tcp->tccps[compno];
209 tccp->numresolutions=cio_read(1)+1;
211 img.Decomposition=tccp->numresolutions-1; // <INDEX>
213 tccp->cblkw=cio_read(1)+2;
214 tccp->cblkh=cio_read(1)+2;
215 tccp->cblksty=cio_read(1);
216 tccp->qmfbid=cio_read(1);
217 if (tccp->csty&J2K_CP_CSTY_PRT) {
218 for (i=0; i<tccp->numresolutions; i++) {
220 tccp->prcw[i]=tmp&0xf;
221 tccp->prch[i]=tmp>>4;
226 void j2k_read_cod() {
229 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
233 if (j2k_state==J2K_STATE_MH)
235 if (!img.marker_mul.num_COD)
236 img.marker_mul.COD=(info_marker_t*)malloc(sizeof(info_marker_t));
238 img.marker_mul.COD=realloc(img.marker_mul.COD,(1+img.marker_mul.num_COD)*sizeof(info_marker_t));
239 img.marker_mul.COD[img.marker_mul.num_COD].type=J2K_MS_COD;
240 img.marker_mul.COD[img.marker_mul.num_COD].start_pos=cio_tell()-2;
241 img.marker_mul.COD[img.marker_mul.num_COD].len=len;
242 img.marker_mul.num_COD++;
247 tcp->csty=cio_read(1);
248 tcp->prg=cio_read(1);
249 tcp->numlayers=cio_read(2);
250 tcp->mct=cio_read(1);
252 for (i=0; i<j2k_img->numcomps; i++) {
253 tcp->tccps[i].csty=tcp->csty&J2K_CP_CSTY_PRT;
259 img.Layer=tcp->numlayers;
263 void j2k_read_coc() {
266 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
269 if (j2k_state==J2K_STATE_MH)
271 if (!img.marker_mul.num_COC)
272 img.marker_mul.COC=(info_marker_t*)malloc(sizeof(info_marker_t));
274 img.marker_mul.COC=realloc(img.marker_mul.COC,(1+img.marker_mul.num_COC)*sizeof(info_marker_t));
275 img.marker_mul.COC[img.marker_mul.num_COC].type=J2K_MS_COC;
276 img.marker_mul.COC[img.marker_mul.num_COC].start_pos=cio_tell()-2;
277 img.marker_mul.COC[img.marker_mul.num_COC].len=len;
278 img.marker_mul.num_COC++;
283 compno=cio_read(j2k_img->numcomps<=256?1:2);
284 tcp->tccps[compno].csty=cio_read(1);
285 j2k_read_cox(compno);
288 void j2k_read_qcx(int compno, int len) {
292 int bandno, numbands;
293 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
294 tccp=&tcp->tccps[compno];
296 tccp->qntsty=tmp&0x1f;
297 tccp->numgbits=tmp>>5;
298 numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:(tccp->qntsty==J2K_CCP_QNTSTY_NOQNT?len-1:(len-1)/2);
299 for (bandno=0; bandno<numbands; bandno++) {
301 if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { // WHY STEPSIZES WHEN NOQNT ?
309 tccp->stepsizes[bandno].expn=expn;
310 tccp->stepsizes[bandno].mant=mant;
314 void j2k_read_qcd() {
319 if (j2k_state==J2K_STATE_MH)
321 img.marker[img.num_marker].type=J2K_MS_QCD;
322 img.marker[img.num_marker].start_pos=cio_tell()-2;
323 img.marker[img.num_marker].len=len;
330 for (i=0; i<j2k_img->numcomps; i++) {
332 j2k_read_qcx(i, len-2);
336 void j2k_read_qcc() {
341 if (j2k_state==J2K_STATE_MH)
343 if (!img.marker_mul.num_QCC)
344 img.marker_mul.QCC=(info_marker_t*)malloc(sizeof(info_marker_t));
346 img.marker_mul.QCC=realloc(img.marker_mul.QCC,(1+img.marker_mul.num_QCC)*sizeof(info_marker_t));
347 img.marker_mul.QCC[img.marker_mul.num_QCC].type=J2K_MS_QCC;
348 img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos=cio_tell()-2;
349 img.marker_mul.QCC[img.marker_mul.num_QCC].len=len;
350 img.marker_mul.num_QCC++;
355 compno=cio_read(j2k_img->numcomps<=256?1:2);
356 j2k_read_qcx(compno, len-2-(j2k_img->numcomps<=256?1:2));
359 void j2k_read_poc() {
360 int len, numpchgs, i;
362 fprintf(stderr, "WARNING: POC marker segment processing not fully implemented\n");
363 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
367 if (j2k_state==J2K_STATE_MH)
369 img.marker[img.num_marker].type=J2K_MS_POC;
370 img.marker[img.num_marker].start_pos=cio_tell()-2;
371 img.marker[img.num_marker].len=len;
377 numpchgs=(len-2)/(5+2*(j2k_img->numcomps<=256?1:2));
378 for (i=0; i<numpchgs; i++) {
381 poc->resno0=cio_read(1);
382 poc->compno0=cio_read(j2k_img->numcomps<=256?1:2);
383 poc->layno1=cio_read(2);
384 poc->resno1=cio_read(1);
385 poc->compno1=cio_read(j2k_img->numcomps<=256?1:2);
386 poc->prg=cio_read(1);
390 void j2k_read_crg() {
395 if (j2k_state==J2K_STATE_MH)
397 img.marker[img.num_marker].type=J2K_MS_CRG;
398 img.marker[img.num_marker].start_pos=cio_tell()-2;
399 img.marker[img.num_marker].len=len;
404 fprintf(stderr, "WARNING: CRG marker segment processing not implemented\n");
408 void j2k_read_tlm() {
413 if (j2k_state==J2K_STATE_MH)
415 if (!img.marker_mul.num_TLM)
416 img.marker_mul.TLM=(info_marker_t*)malloc(sizeof(info_marker_t));
418 img.marker_mul.TLM=realloc(img.marker_mul.TLM,(1+img.marker_mul.num_TLM)*sizeof(info_marker_t));
419 img.marker_mul.TLM[img.marker_mul.num_TLM].type=J2K_MS_TLM;
420 img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos=cio_tell()-2;
421 img.marker_mul.TLM[img.marker_mul.num_TLM].len=len;
422 img.marker_mul.num_TLM++;
426 fprintf(stderr, "WARNING: TLM marker segment processing not implemented\n");
430 void j2k_read_plm() {
435 if (j2k_state==J2K_STATE_MH)
437 if (!img.marker_mul.num_PLM)
438 img.marker_mul.PLM=(info_marker_t*)malloc(sizeof(info_marker_t));
440 img.marker_mul.PLM=realloc(img.marker_mul.PLM,(1+img.marker_mul.num_PLM)*sizeof(info_marker_t));
441 img.marker_mul.PLM[img.marker_mul.num_PLM].type=J2K_MS_PLM;
442 img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos=cio_tell()-2;
443 img.marker_mul.PLM[img.marker_mul.num_PLM].len=len;
444 img.marker_mul.num_PLM++;
448 fprintf(stderr, "WARNING: PLM marker segment processing not implemented\n");
452 void j2k_read_plt() {
455 fprintf(stderr, "WARNING: PLT marker segment processing not implemented\n");
459 void j2k_read_ppm() {
463 if (j2k_state==J2K_STATE_MH)
465 img.marker[img.num_marker].type=J2K_MS_PPM;
466 img.marker[img.num_marker].start_pos=cio_tell()-2;
467 img.marker[img.num_marker].len=len;
472 fprintf(stderr, "WARNING: PPM marker segment processing not implemented\n");
476 void j2k_read_ppt() {
479 fprintf(stderr, "WARNING: PPT marker segment processing not implemented\n");
483 void j2k_read_sot() {
484 int len, tileno, totlen, partno, numparts, i;
490 if (!tileno) img.Main_head_end=cio_tell()-6; // Correction End = First byte of first SOT
491 img.tile[tileno].start_pos=cio_tell()-6;
492 img.tile[tileno].num_tile=tileno;
495 if (!totlen) totlen = cio_numbytesleft() + 8;
497 img.tile[tileno].end_pos=totlen+img.tile[tileno].start_pos; // <INDEX>
500 numparts=cio_read(1);
501 j2k_curtileno=tileno;
502 j2k_eot=cio_getbp()-12+totlen;
503 j2k_state=J2K_STATE_TPH;
504 tcp=&j2k_cp->tcps[j2k_curtileno];
506 *tcp=j2k_default_tcp;
508 for (i=0; i<j2k_img->numcomps; i++) {
509 tcp->tccps[i]=j2k_default_tcp.tccps[i];
513 void j2k_read_sod() {
516 img.tile[j2k_curtileno].end_header=cio_tell()-1; //<INDEX>
517 len=int_min(j2k_eot-cio_getbp(), cio_numbytesleft());
518 j2k_tile_len[j2k_curtileno]+=len;
519 data=(unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
520 memcpy(data, cio_getbp(), len);
521 j2k_tile_data[j2k_curtileno]=data;
523 j2k_state=J2K_STATE_TPHSOT;
527 void j2k_read_rgn() {
528 int len, compno, roisty;
530 tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
534 if (j2k_state==J2K_STATE_MH)
536 if (!img.marker_mul.num_RGN)
537 img.marker_mul.RGN=(info_marker_t*)malloc(sizeof(info_marker_t));
539 img.marker_mul.RGN=realloc(img.marker_mul.RGN,(1+img.marker_mul.num_RGN)*sizeof(info_marker_t));
540 img.marker_mul.RGN[img.marker_mul.num_RGN].type=J2K_MS_RGN;
541 img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos=cio_tell()-2;
542 img.marker_mul.RGN[img.marker_mul.num_RGN].len=len;
543 img.marker_mul.num_RGN++;
548 compno=cio_read(j2k_img->numcomps<=256?1:2);
550 tcp->tccps[compno].roishift=cio_read(1);
553 void j2k_read_eoc() {
555 tcd_init(j2k_img, j2k_cp, &img);
556 for (tileno=0; tileno<j2k_cp->tw*j2k_cp->th; tileno++) {
557 tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno, &img);
560 j2k_state=J2K_STATE_MT;
561 longjmp(j2k_error, 1);
565 void j2k_read_unk() {
566 fprintf(stderr, "warning: unknown marker\n");
569 int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len){
572 int pos_iptr, end_pos;
573 int len_cidx, pos_cidx;
574 int len_jp2c, pos_jp2c;
575 int len_fidx, pos_fidx;
577 dest=fopen(Idx_file, "wb");
579 fprintf(stderr,"Failed to open %s for reading !!\n",Idx_file);
584 index=(char*)malloc(len);
585 cio_init(index, len);
589 jp2_write_jp2h(j2k_img);
590 jp2_write_dbtl(Idx_file);
593 cio_skip(24); // IPTR further !
596 len_jp2c=jp2_write_jp2c(J2K_file);
599 len_cidx=jpip_write_cidx(pos_jp2c+8,img, j2k_cp); // Correction len_jp2C --> pos_jp2c+8
602 len_fidx=jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
606 jpip_write_iptr(pos_fidx,len_fidx);
609 fwrite(index, 1, cio_tell(), dest);
622 } j2k_dec_mstabent_t;
624 j2k_dec_mstabent_t j2k_dec_mstab[]={
625 {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
626 {J2K_MS_SOT, J2K_STATE_MH|J2K_STATE_TPHSOT, j2k_read_sot},
627 {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
628 {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
629 {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
630 {J2K_MS_COD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_cod},
631 {J2K_MS_COC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_coc},
632 {J2K_MS_RGN, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_rgn},
633 {J2K_MS_QCD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcd},
634 {J2K_MS_QCC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcc},
635 {J2K_MS_POC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_poc},
636 {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
637 {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
638 {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
639 {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
640 {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
642 {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
643 {J2K_MS_COM, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_com},
644 {0, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_unk}
647 j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
648 j2k_dec_mstabent_t *e;
649 for (e=j2k_dec_mstab; e->id!=0; e++) {
657 LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
658 if (setjmp(j2k_error)) {
659 if (j2k_state!=J2K_STATE_MT) {
660 fprintf(stderr, "WARNING: incomplete bitstream\n");
663 return cio_numbytes();
665 j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
666 j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
669 j2k_state=J2K_STATE_MHSOC;
672 j2k_dec_mstabent_t *e;
675 fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id);
678 e=j2k_dec_mstab_lookup(id);
679 if (!(j2k_state & e->states)) {
680 fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id);
693 BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
694 switch (ul_reason_for_call) {
695 case DLL_PROCESS_ATTACH:
696 case DLL_THREAD_ATTACH:
697 case DLL_THREAD_DETACH:
698 case DLL_PROCESS_DETACH:
706 extern info_image_t img;
709 int main(int argc, char **argv)
719 fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file\n\n");
723 src=fopen(argv[1], "rb");
725 fprintf(stderr,"Failed to open %s for reading !!\n",argv[1]);
729 // length of the codestream
730 fseek(src, 0, SEEK_END);
732 fseek(src, 0, SEEK_SET);
734 j2kfile=(char*)malloc(totlen);
735 fread(j2kfile, 1, totlen, src);
737 img.marker=(info_marker_t*)malloc(32*sizeof(info_marker_t));
739 img.marker_mul.num_COD=0;
740 img.marker_mul.num_COC=0;
741 img.marker_mul.num_RGN=0;
742 img.marker_mul.num_QCC=0;
743 img.marker_mul.num_TLM=0;
744 img.marker_mul.num_PLM=0;
745 img.marker_mul.num_COM=0;
749 if (!j2k_decode(j2kfile, totlen, &imgg, &cp)) {
750 fprintf(stderr, "Index_creator: failed to decode image!\n");
756 fseek(src, 0, SEEK_SET);
757 img.codestream_size=totlen;
759 j2k_index_JPIP(argv[2],argv[1],totlen*2>30000?totlen*2:30000);