return bio_bp-bio_start;
}
-/// <summary>
-/// Init encoder.
-/// </summary>
-/// <param name="bp">Output buffer</param>
-/// <param name="len">Output buffer length</param>
-void bio_init_enc(unsigned char *bp, int len) {
- bio_start=bp;
- bio_end=bp+len;
- bio_bp=bp;
- bio_buf=0;
- bio_ct=8;
-}
-
/// <summary>
/// Init decoder.
/// </summary>
bio_ct=0;
}
-/// <summary>
-/// Write byte.
-/// </summary>
-int bio_byteout() {
- bio_buf=(bio_buf<<8)&0xffff;
- bio_ct=bio_buf==0xff00?7:8;
- if (bio_bp>=bio_end) return 1; //longjmp(j2k_error, 1);
- *bio_bp++=bio_buf>>8;
- return 0;
+int bio_byteout()
+{
+ bio_buf = (bio_buf << 8) & 0xffff;
+ bio_ct = bio_buf == 0xff00 ? 7 : 8;
+ if (bio_bp >= bio_end)
+ return 1;
+ *bio_bp++ = bio_buf >> 8;
+ return 0;
}
/// <summary>
return 0;
}
-/// <summary>
-/// Write bit.
-/// </summary>
-/// <param name="b">Bit to write (0 or 1)</param>
-void bio_putbit(int b) {
- if (bio_ct==0) {
- bio_byteout();
- }
- bio_ct--;
- bio_buf|=b<<bio_ct;
-}
-
/// <summary>
/// Read bit.
/// </summary>
return (bio_buf>>bio_ct)&1;
}
-/// <summary>
-/// Write bits.
-/// </summary>
-/// <param name="v">Value of bits</param>
-/// <param name="n">Number of bits to write</param>
-void bio_write(int v, int n) {
- int i;
- for (i=n-1; i>=0; i--) {
- bio_putbit((v>>i)&1);
- }
-}
-
/// <summary>
/// Read bits.
/// </summary>
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#define __BIO_H
int bio_numbytes();
-void bio_init_enc(unsigned char *bp, int len);
void bio_init_dec(unsigned char *bp, int len);
-void bio_write(int v, int n);
int bio_read(int n);
int bio_flush();
int bio_inalign();
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
/// <summary>
/// Read some bytes.
/// </summary>
-unsigned int cio_read(int n) {
+/* unsigned int cio_read(int n) { */
+long long cio_read(int n) {
int i;
- unsigned int v;
+ /*unsigned int v;*/
+ long long v;
v=0;
for (i=n-1; i>=0; i--) {
- v+=cio_bytein()<<(i<<3);
+ v+=cio_bytein()<<(i<<3);
}
return v;
}
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
int cio_numbytesleft();
unsigned char *cio_getbp();
void cio_init(unsigned char *bp, int len);
-//void cio_write(unsigned int v, int n);
+/* void cio_write(unsigned int v, int n); */
void cio_write(long long v, int n);
-unsigned int cio_read(int n);
+/* unsigned int cio_read(int n); */
+long long cio_read(int n);
void cio_skip(int n);
#endif
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#define J2K_STATE_TPH 0x0010
#define J2K_STATE_MT 0x0020
+#define START_NB 5
+#define INCREMENT 5
+
jmp_buf j2k_error;
static int j2k_state;
static info_image_t img;
+
void j2k_clean() {
int tileno = 0;
- int compno, resno, precno;
-
- tcd_free(j2k_img,j2k_cp);
-
- for (tileno=0;tileno<j2k_cp->tw*j2k_cp->th;tileno++) {
+ int compno=0, resno=0, precno=0;
+
+ tcd_free(j2k_img, j2k_cp);
+ for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {
info_tile_t *tile_Idx = &img.tile[tileno];
- for (compno=0;compno<img.Comp;compno++)
+ for (compno = 0; compno < img.Comp; compno++)
{
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
-
- for(resno=0;resno<img.Decomposition+1;resno++)
+ for(resno = 0; resno < img.Decomposition + 1; resno++)
{
info_reso_t *reso_Idx = &compo_Idx->reso[resno];
- for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
+ for (precno = 0; precno < img.tile[tileno].pw * img.tile[tileno].ph; precno++)
{
info_prec_t *prec_Idx = &reso_Idx->prec[precno];
free(prec_Idx->layer);
free(compo_Idx->reso);
}
free(tile_Idx->compo);
- }
+ free(tile_Idx->marker);
+ free(tile_Idx->tile_parts);
+ free(tile_Idx->marker_mul.COC);
+ free(tile_Idx->marker_mul.RGN);
+ free(tile_Idx->marker_mul.QCC);
+ free(tile_Idx->marker_mul.PLT);
+ free(tile_Idx->marker_mul.PPT);
+ free(tile_Idx->marker_mul.COM);
+}
free(img.tile);
free(img.marker);
+ free(img.marker_mul.COC);
+ free(img.marker_mul.RGN);
+ free(img.marker_mul.QCC);
+ free(img.marker_mul.PLM);
+ free(img.marker_mul.PPM);
+ free(img.marker_mul.COM);
}
+
+
void j2k_read_soc() {
- j2k_state=J2K_STATE_MHSIZ;
+ j2k_state=J2K_STATE_MHSIZ;
}
+
+
void j2k_read_siz() {
int len, i;
- len=cio_read(2);
+ info_tile_t *tile;
- // <INDEX>
- img.marker[img.num_marker].type=J2K_MS_SIZ;
- img.marker[img.num_marker].start_pos=cio_tell()-2;
- img.marker[img.num_marker].len=len;
- img.num_marker++;
- // </INDEX>
+ len = cio_read(2);
+ /* <INDEX> [MHIX BOX] */
+ img.marker[img.num_marker].type = J2K_MS_SIZ;
+ img.marker[img.num_marker].start_pos = cio_tell()-2;
+ img.marker[img.num_marker].len = len;
+ img.num_marker++;
+ /* </INDEX> [MHIX BOX] */
- cio_read(2); // Rsiz (capabilities)
- j2k_img->x1=cio_read(4); // Xsiz
- j2k_img->y1=cio_read(4); // Ysiz
- j2k_img->x0=cio_read(4); // X0siz
- j2k_img->y0=cio_read(4); // Y0siz
- j2k_cp->tdx=cio_read(4); // XTsiz
- j2k_cp->tdy=cio_read(4); // YTsiz
- j2k_cp->tx0=cio_read(4); // XT0siz
- j2k_cp->ty0=cio_read(4); // YTOsiz
- j2k_img->numcomps=cio_read(2); // Csiz
- j2k_img->comps=(j2k_comp_t*)malloc(j2k_img->numcomps*sizeof(j2k_comp_t));
- for (i=0; i<j2k_img->numcomps; i++) {
+ cio_read(2); /* Rsiz (capabilities) */
+ j2k_img->x1 = cio_read(4); /* Xsiz */
+ j2k_img->y1 = cio_read(4); /* Ysiz */
+ j2k_img->x0 = cio_read(4); /* X0siz */
+ j2k_img->y0 = cio_read(4); /* Y0siz */
+ j2k_cp->tdx = cio_read(4); /* XTsiz */
+ j2k_cp->tdy = cio_read(4); /* YTsiz */
+ j2k_cp->tx0 = cio_read(4); /* XT0siz */
+ j2k_cp->ty0 = cio_read(4); /* YTOsiz */
+
+ j2k_img->numcomps = cio_read(2); /* Csiz */
+ j2k_img->comps = (j2k_comp_t*)malloc(j2k_img->numcomps * sizeof(j2k_comp_t));
+ for (i = 0; i < j2k_img->numcomps; i++) {
int tmp, w, h;
- tmp=cio_read(1);
- j2k_img->comps[i].prec=(tmp&0x7f)+1;
- j2k_img->comps[i].sgnd=tmp>>7;
- j2k_img->comps[i].dx=cio_read(1);
- j2k_img->comps[i].dy=cio_read(1);
- w=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
- h=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
- j2k_img->comps[i].data=(int*)malloc(sizeof(int)*w*h);
+ tmp = cio_read(1);
+ j2k_img->comps[i].prec = (tmp & 0x7f) + 1;
+ j2k_img->comps[i].sgnd = tmp >> 7;
+ j2k_img->comps[i].dx = cio_read(1);
+ j2k_img->comps[i].dy = cio_read(1);
+ w = int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
+ h = int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
+ j2k_img->comps[i].data = (int*)malloc(sizeof(int) * w * h);
}
- j2k_cp->tw=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_cp->tdx);
- j2k_cp->th=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_cp->tdy);
+ j2k_cp->tw = int_ceildiv(j2k_img->x1 - j2k_cp->tx0, j2k_cp->tdx);
+ j2k_cp->th = int_ceildiv(j2k_img->y1 - j2k_cp->ty0, j2k_cp->tdy);
+
+ j2k_cp->tcps = (j2k_tcp_t*)calloc((j2k_cp->tw * j2k_cp->th), sizeof(j2k_tcp_t));
- j2k_cp->tcps=(j2k_tcp_t*)calloc(sizeof(j2k_tcp_t), j2k_cp->tw*j2k_cp->th);
- j2k_default_tcp.tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
- for (i=0; i<j2k_cp->tw*j2k_cp->th; i++) {
- j2k_cp->tcps[i].tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
+ for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++)
+ {
+ j2k_cp->tcps[i].POC = 0;
+ j2k_cp->tcps[i].numpocs = 0;
+ // j2k_cp->tcps[i].first=1;
+ }
+
+ /* Initialization for PPM marker */
+ j2k_cp->ppm = 0;
+ j2k_cp->ppm_data = NULL;
+ j2k_cp->ppm_previous = 0;
+ j2k_cp->ppm_store = 0;
+
+ j2k_default_tcp.tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
+ for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {
+ j2k_cp->tcps[i].tccps = (j2k_tccp_t*)malloc(j2k_img->numcomps * sizeof(j2k_tccp_t));
}
- j2k_tile_data=(unsigned char**)calloc(j2k_cp->tw*j2k_cp->th, sizeof(char*));
- j2k_tile_len=(int*)calloc(j2k_cp->tw*j2k_cp->th, sizeof(int));
- j2k_state=J2K_STATE_MH;
-
- // <INDEX>
- img.Im_w=j2k_img->x1-j2k_img->x0;
- img.Im_h=j2k_img->y1-j2k_img->y0;
- img.Tile_x=j2k_cp->tdx;
- img.Tile_y=j2k_cp->tdy;
- img.Comp=j2k_img->numcomps;
- img.tw=j2k_cp->tw;
- img.th=j2k_cp->th;
- img.tile=(info_tile_t*)malloc((img.tw*img.th)*sizeof(info_tile_t));
- //</INDEX>
+ j2k_tile_data = (unsigned char**)calloc(j2k_cp->tw * j2k_cp->th, sizeof(char*));
+ j2k_tile_len = (int*)calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));
+ j2k_state = J2K_STATE_MH;
+
+ /* <INDEX> */
+ img.Im_w = j2k_img->x1 - j2k_img->x0;
+ img.Im_h = j2k_img->y1 - j2k_img->y0;
+ img.Tile_x = j2k_cp->tdx;
+ img.Tile_y = j2k_cp->tdy;
+ img.Comp = j2k_img->numcomps;
+ img.tw = j2k_cp->tw;
+ img.th = j2k_cp->th;
+ img.tile = (info_tile_t*)malloc(img.tw * img.th * sizeof(info_tile_t));
+
+ for (i = 0; i < img.tw * img.th; i++)
+ {
+ tile = &img.tile[i];
+ tile->marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
+ tile->num_marker = 0;
+ tile->marker_mul.num_COC = 0;
+ tile->marker_mul.CzCOC = START_NB;
+ tile->marker_mul.num_RGN = 0;
+ tile->marker_mul.CzRGN = START_NB;
+ tile->marker_mul.num_QCC = 0;
+ tile->marker_mul.CzQCC = START_NB;
+ tile->marker_mul.num_PLT = 0;
+ tile->marker_mul.CzPLT = START_NB;
+ tile->marker_mul.num_PPT = 0;
+ tile->marker_mul.CzPPT = START_NB;
+ tile->marker_mul.num_COM = 0;
+ tile->marker_mul.CzCOM = START_NB;
+ }
+ /* </INDEX> */
}
void j2k_read_com() {
int len;
- len=cio_read(2);
+ info_tile_t *tile;
+ info_marker_t *tmp;
+
+ len = cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
- if (!img.marker_mul.num_COM)
- img.marker_mul.COM=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.COM=realloc(img.marker_mul.COM,(1+img.marker_mul.num_COM)*sizeof(info_marker_t));
- img.marker_mul.COM[img.marker_mul.num_COM].type=J2K_MS_COM;
- img.marker_mul.COM[img.marker_mul.num_COM].start_pos=cio_tell()-2;
- img.marker_mul.COM[img.marker_mul.num_COM].len=len;
- img.marker_mul.num_COM++;
- }
- // </INDEX>
+ if (!img.marker_mul.num_COM)
+ img.marker_mul.COM = (info_marker_t*)malloc(img.marker_mul.CzCOM * sizeof(info_marker_t));
+ if (img.marker_mul.num_COM >= img.marker_mul.CzCOM)
+ {
+ tmp = (info_marker_t*)malloc(2 * img.marker_mul.CzCOM * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.COM,img.marker_mul.CzCOM);
+ img.marker_mul.CzCOM *= 2;
+ free(img.marker_mul.COM);
+ img.marker_mul.COM = tmp;
+ }
- cio_skip(len-2);
+ img.marker_mul.COM[img.marker_mul.num_COM].type = J2K_MS_COM;
+ img.marker_mul.COM[img.marker_mul.num_COM].start_pos = cio_tell()-2;
+ img.marker_mul.COM[img.marker_mul.num_COM].len = len;
+ img.marker_mul.num_COM++;
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ if (!tile->marker_mul.num_COM)
+ tile->marker_mul.COM = (info_marker_t*)calloc(START_NB, sizeof(info_marker_t));
+ if (tile->marker_mul.num_COM >= tile->marker_mul.CzCOM)
+ {
+ tmp = (info_marker_t*)malloc(2 * tile->marker_mul.CzCOM * sizeof(info_marker_t));
+ memcpy(tmp,tile->marker_mul.COM,tile->marker_mul.CzCOM);
+ tile->marker_mul.CzCOM *= 2;
+ free(tile->marker_mul.COM);
+ tile->marker_mul.COM = tmp;
+ }
+ tile->marker_mul.COM[tile->marker_mul.num_COM].type = J2K_MS_COM;
+ tile->marker_mul.COM[tile->marker_mul.num_COM].start_pos = cio_tell()-2;
+ tile->marker_mul.COM[tile->marker_mul.num_COM].len = len;
+ tile->marker_mul.num_COM++;
+ }
+ /* </INDEX> [MHIX BOX] */
+
+ cio_skip(len - 2);
}
+
+
+
void j2k_read_cox(int compno) {
int i;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- tccp=&tcp->tccps[compno];
- tccp->numresolutions=cio_read(1)+1;
- img.Decomposition=tccp->numresolutions-1; // <INDEX>
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ tccp = &tcp->tccps[compno];
+ tccp->numresolutions = cio_read(1) + 1;
+
+ img.Decomposition = tccp->numresolutions - 1; /* <INDEX> */
- tccp->cblkw=cio_read(1)+2;
- tccp->cblkh=cio_read(1)+2;
- tccp->cblksty=cio_read(1);
- tccp->qmfbid=cio_read(1);
+ tccp->cblkw = cio_read(1) + 2;
+ tccp->cblkh = cio_read(1) + 2;
+ tccp->cblksty = cio_read(1);
+ tccp->qmfbid = cio_read(1);
if (tccp->csty&J2K_CP_CSTY_PRT) {
- for (i=0; i<tccp->numresolutions; i++) {
- int tmp=cio_read(1);
- tccp->prcw[i]=tmp&0xf;
- tccp->prch[i]=tmp>>4;
+ for (i = 0; i < tccp->numresolutions; i++) {
+ int tmp = cio_read(1);
+ tccp->prcw[i] = tmp&0xf;
+ tccp->prch[i] = tmp>>4;
}
}
}
+
+
+
void j2k_read_cod() {
int len, i, pos;
j2k_tcp_t *tcp;
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- len=cio_read(2);
+ info_tile_t *tile;
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
- if (!img.marker_mul.num_COD)
- img.marker_mul.COD=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.COD=realloc(img.marker_mul.COD,(1+img.marker_mul.num_COD)*sizeof(info_marker_t));
- img.marker_mul.COD[img.marker_mul.num_COD].type=J2K_MS_COD;
- img.marker_mul.COD[img.marker_mul.num_COD].start_pos=cio_tell()-2;
- img.marker_mul.COD[img.marker_mul.num_COD].len=len;
- img.marker_mul.num_COD++;
+ img.marker[img.num_marker].type = J2K_MS_SIZ;
+ img.marker[img.num_marker].start_pos = cio_tell()-2;
+ img.marker[img.num_marker].len = len;
+ img.num_marker++;
}
- // </INDEX>
-
+ else
+ {
+ tile = &img.tile[j2k_curtileno];
+ tile->marker[tile->num_marker].type = J2K_MS_SIZ;
+ tile->marker[tile->num_marker].start_pos = cio_tell()-2;
+ tile->marker[tile->num_marker].len = len;
+ tile->num_marker++;
+ }
+ /* </INDEX> [MHIX BOX] */
- tcp->csty=cio_read(1);
- tcp->prg=cio_read(1);
- tcp->numlayers=cio_read(2);
- tcp->mct=cio_read(1);
- pos=cio_tell();
- for (i=0; i<j2k_img->numcomps; i++) {
- tcp->tccps[i].csty=tcp->csty&J2K_CP_CSTY_PRT;
+ tcp->csty = cio_read(1);
+ tcp->prg = cio_read(1);
+ tcp->numlayers = cio_read(2);
+ tcp->mct = cio_read(1);
+
+ pos = cio_tell();
+ for (i = 0; i < j2k_img->numcomps; i++) {
+ tcp->tccps[i].csty = tcp->csty&J2K_CP_CSTY_PRT;
cio_seek(pos);
j2k_read_cox(i);
}
- //<INDEX>
- img.Prog=tcp->prg;
- img.Layer=tcp->numlayers;
- //</INDEX>
+
+ /* <INDEX> */
+ img.Prog = tcp->prg;
+ img.Layer = tcp->numlayers;
+ /* </INDEX> */
}
+
+
+
void j2k_read_coc() {
int len, compno;
j2k_tcp_t *tcp;
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- len=cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ info_tile_t *tile;
+ info_marker_t *tmp;
+
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
if (!img.marker_mul.num_COC)
- img.marker_mul.COC=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.COC=realloc(img.marker_mul.COC,(1+img.marker_mul.num_COC)*sizeof(info_marker_t));
- img.marker_mul.COC[img.marker_mul.num_COC].type=J2K_MS_COC;
- img.marker_mul.COC[img.marker_mul.num_COC].start_pos=cio_tell()-2;
- img.marker_mul.COC[img.marker_mul.num_COC].len=len;
+ img.marker_mul.COC = (info_marker_t*)malloc(img.marker_mul.CzCOC * sizeof(info_marker_t));
+ if (img.marker_mul.num_COC >= img.marker_mul.CzCOC)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzCOC) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.COC,img.marker_mul.CzCOC);
+ img.marker_mul.CzCOC += INCREMENT;
+ free(img.marker_mul.COC);
+ img.marker_mul.COC = tmp;
+ }
+ img.marker_mul.COC[img.marker_mul.num_COC].type = J2K_MS_COC;
+ img.marker_mul.COC[img.marker_mul.num_COC].start_pos = cio_tell()-2;
+ img.marker_mul.COC[img.marker_mul.num_COC].len = len;
img.marker_mul.num_COC++;
- }
- // </INDEX>
-
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ if (!tile->marker_mul.num_COC)
+ tile->marker_mul.COC = (info_marker_t*)malloc(tile->marker_mul.CzCOC * sizeof(info_marker_t));
+ if (tile->marker_mul.num_COC >= tile->marker_mul.CzCOC)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzCOC) * sizeof(info_marker_t));
+ memcpy(tmp,tile->marker_mul.COC,tile->marker_mul.CzCOC);
+ tile->marker_mul.CzCOC += INCREMENT;
+ free(tile->marker_mul.COC);
+ tile->marker_mul.COC = tmp;
+ }
+ tile->marker_mul.COC[tile->marker_mul.num_COC].type = J2K_MS_COC;
+ tile->marker_mul.COC[tile->marker_mul.num_COC].start_pos = cio_tell() - 2;
+ tile->marker_mul.COC[tile->marker_mul.num_COC].len = len;
+ tile->marker_mul.num_COC++;
+ }
+ /* </INDEX> [MHIX BOX] */
- compno=cio_read(j2k_img->numcomps<=256?1:2);
- tcp->tccps[compno].csty=cio_read(1);
+ compno =cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
+
+ tcp->tccps[compno].csty = cio_read(1);
j2k_read_cox(compno);
}
+
+
+
void j2k_read_qcx(int compno, int len) {
int tmp;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
int bandno, numbands;
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- tccp=&tcp->tccps[compno];
- tmp=cio_read(1);
- tccp->qntsty=tmp&0x1f;
- tccp->numgbits=tmp>>5;
- numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:(tccp->qntsty==J2K_CCP_QNTSTY_NOQNT?len-1:(len-1)/2);
- for (bandno=0; bandno<numbands; bandno++) {
+
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ tccp = &tcp->tccps[compno];
+ tmp = cio_read(1);
+ tccp->qntsty = tmp & 0x1f;
+ tccp->numgbits = tmp >> 5;
+ numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT ? len - 1 : (len - 1) / 2);
+ for (bandno = 0; bandno < numbands; bandno++) {
int expn, mant;
- if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { // WHY STEPSIZES WHEN NOQNT ?
- expn=cio_read(1)>>3;
- mant=0;
+ if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) { /* WHY STEPSIZES WHEN NOQNT ? */
+ expn = cio_read(1) >> 3;
+ mant = 0;
} else {
- tmp=cio_read(2);
- expn=tmp>>11;
- mant=tmp&0x7ff;
+ tmp = cio_read(2);
+ expn = tmp >> 11;
+ mant = tmp & 0x7ff;
}
- tccp->stepsizes[bandno].expn=expn;
- tccp->stepsizes[bandno].mant=mant;
+ tccp->stepsizes[bandno].expn = expn;
+ tccp->stepsizes[bandno].mant = mant;
}
}
+
+
+
void j2k_read_qcd() {
int len, i, pos;
- len=cio_read(2);
+ info_tile_t *tile;
+
+ len = cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
- img.marker[img.num_marker].type=J2K_MS_QCD;
- img.marker[img.num_marker].start_pos=cio_tell()-2;
- img.marker[img.num_marker].len=len;
+ img.marker[img.num_marker].type = J2K_MS_QCD;
+ img.marker[img.num_marker].start_pos = cio_tell()-2;
+ img.marker[img.num_marker].len = len;
img.num_marker++;
- }
- // </INDEX>
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ tile->marker[tile->num_marker].type = J2K_MS_QCD;
+ tile->marker[tile->num_marker].start_pos = cio_tell()-2;
+ tile->marker[tile->num_marker].len = len;
+ tile->num_marker++;
+ }
+ /* </INDEX> [MHIX BOX] */
pos=cio_tell();
- for (i=0; i<j2k_img->numcomps; i++) {
+ for (i = 0; i < j2k_img->numcomps; i++) {
cio_seek(pos);
- j2k_read_qcx(i, len-2);
+ j2k_read_qcx(i, len - 2);
}
}
+
+
+
void j2k_read_qcc() {
int len, compno;
- len=cio_read(2);
+ info_tile_t *tile;
+ info_marker_t *tmp;
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ len = cio_read(2);
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
if (!img.marker_mul.num_QCC)
- img.marker_mul.QCC=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.QCC=realloc(img.marker_mul.QCC,(1+img.marker_mul.num_QCC)*sizeof(info_marker_t));
- img.marker_mul.QCC[img.marker_mul.num_QCC].type=J2K_MS_QCC;
- img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos=cio_tell()-2;
- img.marker_mul.QCC[img.marker_mul.num_QCC].len=len;
+ img.marker_mul.QCC = (info_marker_t*)malloc(img.marker_mul.CzQCC * sizeof(info_marker_t));
+ if (img.marker_mul.num_QCC >= img.marker_mul.CzQCC)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzQCC) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.QCC,img.marker_mul.CzQCC);
+ img.marker_mul.CzQCC += INCREMENT;
+ free(img.marker_mul.QCC);
+ img.marker_mul.QCC = tmp;
+ }
+ img.marker_mul.QCC[img.marker_mul.num_QCC].type = J2K_MS_QCC;
+ img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos = cio_tell() - 2;
+ img.marker_mul.QCC[img.marker_mul.num_QCC].len = len;
img.marker_mul.num_QCC++;
- }
- // </INDEX>
-
-
- compno=cio_read(j2k_img->numcomps<=256?1:2);
- j2k_read_qcx(compno, len-2-(j2k_img->numcomps<=256?1:2));
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ if (!tile->marker_mul.num_QCC)
+ tile->marker_mul.QCC = (info_marker_t*)malloc(tile->marker_mul.CzQCC * sizeof(info_marker_t));
+ if (tile->marker_mul.num_QCC >= tile->marker_mul.CzQCC)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzQCC) * sizeof(info_marker_t));
+ memcpy(tmp,tile->marker_mul.QCC,tile->marker_mul.CzQCC);
+ tile->marker_mul.CzQCC += INCREMENT;
+ free(tile->marker_mul.QCC);
+ tile->marker_mul.QCC = tmp;
+ }
+ tile->marker_mul.QCC[tile->marker_mul.num_QCC].type = J2K_MS_QCC;
+ tile->marker_mul.QCC[tile->marker_mul.num_QCC].start_pos = cio_tell()-2;
+ tile->marker_mul.QCC[tile->marker_mul.num_QCC].len = len;
+ tile->marker_mul.num_QCC++;
+ }
+ /* </INDEX> [MHIX BOX] */
+
+ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
+ j2k_read_qcx(compno, len - 2 - (j2k_img->numcomps <= 256 ? 1 : 2));
}
+
+
+
void j2k_read_poc() {
- int len, numpchgs, i;
+ int len, numpchgs, i, old_poc;
j2k_tcp_t *tcp;
- fprintf(stderr, "WARNING: POC marker segment processing not fully implemented\n");
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- len=cio_read(2);
+ j2k_tccp_t *tccp;
+ info_tile_t *tile;
+
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ old_poc = tcp->POC ? tcp->numpocs+1 : 0;
+ tcp->POC = 1;
+ tccp = &tcp->tccps[0];
+ len = cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ /* <INDEX> [MHIX BOX] */
+ if (j2k_state == J2K_STATE_MH)
{
- img.marker[img.num_marker].type=J2K_MS_POC;
- img.marker[img.num_marker].start_pos=cio_tell()-2;
- img.marker[img.num_marker].len=len;
+ img.marker[img.num_marker].type = J2K_MS_POC;
+ img.marker[img.num_marker].start_pos = cio_tell()-2;
+ img.marker[img.num_marker].len = len;
img.num_marker++;
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ tile->marker[tile->num_marker].type = J2K_MS_POC;
+ tile->marker[tile->num_marker].start_pos = cio_tell()-2;
+ tile->marker[tile->num_marker].len = len;
+ tile->num_marker++;
+ }
+ /* </INDEX> [MHIX BOX] */
+
+ numpchgs = (len - 2) / (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2));
+ for (i = 0; i < numpchgs; i++) {
+ j2k_poc_t *poc;
+ poc = &tcp->pocs[i];
+ poc->resno0 = cio_read(1);
+ poc->compno0 = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
+ poc->layno1 = int_min(cio_read(2), tcp->numlayers);
+ poc->resno1 = int_min(cio_read(1), tccp->numresolutions);
+ poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps);
+ poc->prg = cio_read(1);
}
- // </INDEX>
-
- numpchgs=(len-2)/(5+2*(j2k_img->numcomps<=256?1:2));
- for (i=0; i<numpchgs; i++) {
- j2k_poc_t *poc;
- poc=&tcp->pocs[i];
- poc->resno0=cio_read(1);
- poc->compno0=cio_read(j2k_img->numcomps<=256?1:2);
- poc->layno1=cio_read(2);
- poc->resno1=cio_read(1);
- poc->compno1=cio_read(j2k_img->numcomps<=256?1:2);
- poc->prg=cio_read(1);
- }
+ tcp->numpocs = numpchgs + old_poc - 1;
}
+
+
+
void j2k_read_crg() {
- int len;
- len=cio_read(2);
+ int len, i, Xcrg_i, Ycrg_i;
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
- {
- img.marker[img.num_marker].type=J2K_MS_CRG;
- img.marker[img.num_marker].start_pos=cio_tell()-2;
- img.marker[img.num_marker].len=len;
- img.num_marker++;
- }
- // </INDEX>
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX] */
+ img.marker[img.num_marker].type = J2K_MS_CRG;
+ img.marker[img.num_marker].start_pos = cio_tell()-2;
+ img.marker[img.num_marker].len = len;
+ img.num_marker++;
+ /* </INDEX> [MHIX BOX] */
- fprintf(stderr, "WARNING: CRG marker segment processing not implemented\n");
- cio_skip(len-2);
+ for (i = 0; i < j2k_img->numcomps; i++)
+ {
+ Xcrg_i = cio_read(2);
+ Ycrg_i = cio_read(2);
+ }
}
+
+
+
void j2k_read_tlm() {
- int len;
- len=cio_read(2);
+ int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
+ long int Ttlm_i, Ptlm_i;
+ info_marker_t *tmp;
+
+ len = cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ /* <INDEX> [MHIX BOX] */
+ if (!img.marker_mul.num_TLM)
+ img.marker_mul.TLM = (info_marker_t*)malloc(img.marker_mul.CzTLM * sizeof(info_marker_t));
+ if (img.marker_mul.num_TLM >= img.marker_mul.CzTLM)
{
- if (!img.marker_mul.num_TLM)
- img.marker_mul.TLM=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.TLM=realloc(img.marker_mul.TLM,(1+img.marker_mul.num_TLM)*sizeof(info_marker_t));
- img.marker_mul.TLM[img.marker_mul.num_TLM].type=J2K_MS_TLM;
- img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos=cio_tell()-2;
- img.marker_mul.TLM[img.marker_mul.num_TLM].len=len;
- img.marker_mul.num_TLM++;
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzTLM) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.TLM,img.marker_mul.CzTLM);
+ img.marker_mul.CzTLM += INCREMENT;
+ free(img.marker_mul.TLM);
+ img.marker_mul.TLM = tmp;
}
- // </INDEX>
+ img.marker_mul.TLM[img.marker_mul.num_TLM].type = J2K_MS_TLM;
+ img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos = cio_tell()-2;
+ img.marker_mul.TLM[img.marker_mul.num_TLM].len = len;
+ img.marker_mul.num_TLM++;
+ /* </INDEX> [MHIX BOX] */
- fprintf(stderr, "WARNING: TLM marker segment processing not implemented\n");
- cio_skip(len-2);
+ Ztlm = cio_read(1);
+ Stlm = cio_read(1);
+ ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
+ SP = (Stlm >> 6) & 0x01;
+ tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
+ for (i = 0; i < tile_tlm; i++)
+ {
+ Ttlm_i = cio_read(ST);
+ Ptlm_i = cio_read(SP ? 4 : 2);
+ }
}
+
+
+
void j2k_read_plm() {
- int len;
+ int len, i, Z_plm, N_plm, add, packet_len=0;
+ info_marker_t *tmp;
+
len=cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ /* <INDEX> [MHIX BOX] */
+ if (!img.marker_mul.num_PLM)
+ img.marker_mul.PLM = (info_marker_t*)malloc(img.marker_mul.CzPLM * sizeof(info_marker_t));
+ if (img.marker_mul.num_PLM >= img.marker_mul.CzPLM)
{
- if (!img.marker_mul.num_PLM)
- img.marker_mul.PLM=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.PLM=realloc(img.marker_mul.PLM,(1+img.marker_mul.num_PLM)*sizeof(info_marker_t));
- img.marker_mul.PLM[img.marker_mul.num_PLM].type=J2K_MS_PLM;
- img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos=cio_tell()-2;
- img.marker_mul.PLM[img.marker_mul.num_PLM].len=len;
- img.marker_mul.num_PLM++;
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPLM) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.PLM,img.marker_mul.CzPLM);
+ img.marker_mul.CzPLM += INCREMENT;
+ free(img.marker_mul.PLM);
+ img.marker_mul.PLM = tmp;
+ }
+ img.marker_mul.PLM[img.marker_mul.num_PLM].type = J2K_MS_PLM;
+ img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos = cio_tell()-2;
+ img.marker_mul.PLM[img.marker_mul.num_PLM].len = len;
+ img.marker_mul.num_PLM++;
+ /* </INDEX> [MHIX BOX] */
+
+ Z_plm = cio_read(1);
+ len -= 3;
+ while (len > 0)
+ {
+ N_plm = cio_read(4);
+ len -= 4;
+ for (i = N_plm ; i > 0 ; i--)
+ {
+ add = cio_read(1);
+ len--;
+ packet_len = (packet_len << 7) + add;
+ if ((add & 0x80) == 0)
+ {
+ /* New packet */
+ packet_len = 0;
+ }
+ if (len <= 0) break;
+ }
}
- // </INDEX>
-
- fprintf(stderr, "WARNING: PLM marker segment processing not implemented\n");
- cio_skip(len-2);
}
+
+
+
void j2k_read_plt() {
- int len;
- len=cio_read(2);
- fprintf(stderr, "WARNING: PLT marker segment processing not implemented\n");
- cio_skip(len-2);
+ int len, i, Zplt, packet_len=0, add;
+ info_tile_t *tile;
+ info_marker_t *tmp;
+;
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX] */
+ tile = &img.tile[j2k_curtileno];
+ if (!tile->marker_mul.num_PLT)
+ tile->marker_mul.PLT = (info_marker_t*)malloc(tile->marker_mul.CzPLT * sizeof(info_marker_t));
+ if (tile->marker_mul.num_PLT >= tile->marker_mul.CzPLT)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzPLT) * sizeof(info_marker_t));
+ memcpy(tmp,tile->marker_mul.PLT,tile->marker_mul.CzPLT);
+ tile->marker_mul.CzPLT += INCREMENT;
+ free(tile->marker_mul.PLT);
+ tile->marker_mul.PLT = tmp;
+ }
+
+ tile->marker_mul.PLT[tile->marker_mul.num_PLT].type = J2K_MS_PLT;
+ tile->marker_mul.PLT[tile->marker_mul.num_PLT].start_pos = cio_tell()-2;
+ tile->marker_mul.PLT[tile->marker_mul.num_PLT].len = len;
+ tile->marker_mul.num_PLT++;
+ /* </INDEX> [MHIX BOX] */
+
+ Zplt = cio_read(1);
+ for (i = len-3; i > 0; i--)
+ {
+ add = cio_read(1);
+ packet_len = (packet_len << 7) + add;
+ if ((add & 0x80) == 0)
+ {
+ /* New packet */
+ packet_len = 0;
+ }
+ }
}
+
+
+
void j2k_read_ppm() {
- int len;
- len=cio_read(2);
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ int len, Z_ppm, i, j;
+ int N_ppm;
+ info_marker_t *tmp;
+
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX] */
+ if (!img.marker_mul.num_PPM)
+ img.marker_mul.PPM = (info_marker_t*)malloc(img.marker_mul.CzPPM * sizeof(info_marker_t));
+ if (img.marker_mul.num_PPM >= img.marker_mul.CzPPM)
{
- img.marker[img.num_marker].type=J2K_MS_PPM;
- img.marker[img.num_marker].start_pos=cio_tell()-2;
- img.marker[img.num_marker].len=len;
- img.num_marker++;
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzPPM) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.PPM,img.marker_mul.CzPPM);
+ img.marker_mul.CzPPM += INCREMENT;
+ free(img.marker_mul.PPM);
+ img.marker_mul.PPM = tmp;
}
- // </INDEX>
+ img.marker_mul.PLM[img.marker_mul.num_PPM].type = J2K_MS_PPM;
+ img.marker_mul.PLM[img.marker_mul.num_PPM].start_pos = cio_tell()-2;
+ img.marker_mul.PLM[img.marker_mul.num_PPM].len = len;
+ img.marker_mul.num_PPM++;
+ /* </INDEX> [MHIX BOX] */
- fprintf(stderr, "WARNING: PPM marker segment processing not implemented\n");
- cio_skip(len-2);
+ j2k_cp->ppm = 1;
+
+ Z_ppm = cio_read(1); /* Z_ppm */
+ len -= 3;
+ while (len > 0)
+ {
+ if (j2k_cp->ppm_previous == 0)
+ {
+ N_ppm = cio_read(4); /* N_ppm */
+ len -= 4;
+ } else
+ {
+ N_ppm = j2k_cp->ppm_previous;
+ }
+
+ j = j2k_cp->ppm_store;
+ if (Z_ppm == 0) /* First PPM marker */
+ j2k_cp->ppm_data = (unsigned char*)calloc(N_ppm, sizeof(unsigned char));
+ else /* NON-first PPM marker */
+ j2k_cp->ppm_data = (unsigned char*)realloc(j2k_cp->ppm_data, (N_ppm + j2k_cp->ppm_store) * sizeof(unsigned char));
+
+ for (i = N_ppm ; i > 0 ; i--) /* Read packet header */
+ {
+ j2k_cp->ppm_data[j] = cio_read(1);
+ j++;
+ len--;
+ if (len == 0) break; /* Case of non-finished packet header in present marker but finished in next one */
+ }
+
+ j2k_cp->ppm_previous = i - 1;
+ j2k_cp->ppm_store = j;
+ }
}
+
+
+
void j2k_read_ppt() {
- int len;
+ int len, Z_ppt, i, j = 0;
+ j2k_tcp_t *tcp;
+ info_tile_t *tile;
len=cio_read(2);
- fprintf(stderr, "WARNING: PPT marker segment processing not implemented\n");
- cio_skip(len-2);
+
+ /* <INDEX> [MHIX BOX] */
+ tile = & img.tile[j2k_curtileno];
+ tile->marker[tile->num_marker].type = J2K_MS_PPT;
+ tile->marker[tile->num_marker].start_pos = cio_tell()-2;
+ tile->marker[tile->num_marker].len = len;
+ tile->num_marker++;
+ /* </INDEX> [MHIX BOX] */
+
+ Z_ppt = cio_read(1);
+ tcp = &j2k_cp->tcps[j2k_curtileno];
+ tcp->ppt = 1;
+ if (Z_ppt == 0) /* First PPT marker */
+ {
+ tcp->ppt_data = (unsigned char*)calloc(len - 3, sizeof(unsigned char));
+ tcp->ppt_store = 0;
+ }
+ else /* NON-first PPT marker */
+ tcp->ppt_data = (unsigned char*)realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
+
+ j = tcp->ppt_store;
+ for (i = len - 3 ; i > 0 ; i--)
+ {
+ tcp->ppt_data[j] = cio_read(1);
+ j++;
+ }
+ tcp->ppt_store = j;
}
+
+
+
void j2k_read_sot() {
int len, tileno, totlen, partno, numparts, i;
j2k_tcp_t *tcp;
j2k_tccp_t *tmp;
- len=cio_read(2);
- tileno=cio_read(2);
- //<INDEX>
- if (!tileno) img.Main_head_end=cio_tell()-6; // Correction End = First byte of first SOT
- img.tile[tileno].start_pos=cio_tell()-6;
- img.tile[tileno].num_tile=tileno;
- // </INDEX>
- totlen=cio_read(4);
+ info_tile_t *tile;
+ info_tile_part_t *tilepart_tmp;
+
+
+ //fprintf(stderr,"SOT\n");
+ len = cio_read(2);
+ tileno = cio_read(2);
+ /* <INDEX> [MHIX BOX] */
+ tile = & img.tile[tileno];
+ tile->marker[tile->num_marker].type = J2K_MS_SOT;
+ tile->marker[tile->num_marker].start_pos = cio_tell() - 4;
+ tile->marker[tile->num_marker].len = len;
+ tile->num_marker++;
+ /* </INDEX> [MHIX BOX] */
+
+ totlen = cio_read(4);
if (!totlen) totlen = cio_numbytesleft() + 8;
+ partno = cio_read(1);
+ numparts = cio_read(1);
+
+ /* <INDEX> */
+ if (tileno == 0 && partno == 0 )
+ img.Main_head_end = cio_tell() - 7; /* Correction End = First byte of first SOT */
+
+ img.tile[tileno].num_tile = tileno;
+ /* </INDEX> */
+
+ tile->numparts = partno + 1; /* INDEX : Number of tile_parts for the tile */
+ img.num_max_tile_parts = int_max(tile->numparts, img.num_max_tile_parts); /* INDEX : Maximum number of tile_part per tile */
- img.tile[tileno].end_pos=totlen+img.tile[tileno].start_pos; // <INDEX>
-
- partno=cio_read(1);
- numparts=cio_read(1);
- j2k_curtileno=tileno;
- j2k_eot=cio_getbp()-12+totlen;
- j2k_state=J2K_STATE_TPH;
- tcp=&j2k_cp->tcps[j2k_curtileno];
- tmp=tcp->tccps;
- *tcp=j2k_default_tcp;
- tcp->tccps=tmp;
- for (i=0; i<j2k_img->numcomps; i++) {
- tcp->tccps[i]=j2k_default_tcp.tccps[i];
+ if (partno == 0)
+ {
+ tile->tile_parts = (info_tile_part_t*)malloc(START_NB * sizeof(info_tile_part_t*));
+ tile->Cztile_parts = START_NB;
}
-}
+ if (partno >= tile->Cztile_parts)
+ {
+ tilepart_tmp = (info_tile_part_t*)malloc((INCREMENT + tile->Cztile_parts) * sizeof(info_tile_part_t));
+ memcpy(tmp, tile->tile_parts, tile->Cztile_parts);
+ tile->Cztile_parts += INCREMENT;
+ free(tile->tile_parts);
+ tile->tile_parts = tilepart_tmp;
+ }
-void j2k_read_sod() {
- int len;
- unsigned char *data;
- img.tile[j2k_curtileno].end_header=cio_tell()-1; //<INDEX>
- len=int_min(j2k_eot-cio_getbp(), cio_numbytesleft());
- j2k_tile_len[j2k_curtileno]+=len;
- data=(unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
- memcpy(data, cio_getbp(), len);
- j2k_tile_data[j2k_curtileno]=data;
- cio_skip(len);
- j2k_state=J2K_STATE_TPHSOT;
-
+ tile->tile_parts[partno].start_pos = cio_tell() - 12; /* INDEX : start_pos of the tile_part */
+ tile->tile_parts[partno].length = totlen; /* INDEX : length of the tile_part */
+ tile->tile_parts[partno].end_pos = totlen + cio_tell() - 12; /* INDEX : end position of the tile_part */
+
+
+ j2k_curtileno = tileno;
+ j2k_eot = cio_getbp() - 12 + totlen;
+ j2k_state = J2K_STATE_TPH;
+ tcp = &j2k_cp->tcps[j2k_curtileno];
+
+ tile->tile_parts[numparts].num_reso_AUX = tcp->tccps[0].numresolutions; /* INDEX : AUX value for TPIX */
+
+ if (partno == 0)
+ // if (tcp->first == 1)
+ {
+ tmp = tcp->tccps;
+ *tcp = j2k_default_tcp;
+ /* Initialization PPT */
+ tcp->ppt = 0;
+ tcp->ppt_data = NULL;
+
+ tcp->tccps = tmp;
+ for (i = 0; i < j2k_img->numcomps; i++) {
+ tcp->tccps[i] = j2k_default_tcp.tccps[i];
+ }
+ //j2k_cp->tcps[j2k_curtileno].first=0;
+ }
}
+
+
void j2k_read_rgn() {
int len, compno, roisty;
j2k_tcp_t *tcp;
- tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
- len=cio_read(2);
-
- // <INDEX>
- if (j2k_state==J2K_STATE_MH)
+ info_tile_t *tile;
+ info_marker_t *tmp;
+ // fprintf(stderr,"RGN\n");
+ tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
+ len = cio_read(2);
+
+ /* <INDEX> [MHIX BOX]*/
+ if (j2k_state == J2K_STATE_MH)
{
if (!img.marker_mul.num_RGN)
- img.marker_mul.RGN=(info_marker_t*)malloc(sizeof(info_marker_t));
- else
- img.marker_mul.RGN=realloc(img.marker_mul.RGN,(1+img.marker_mul.num_RGN)*sizeof(info_marker_t));
- img.marker_mul.RGN[img.marker_mul.num_RGN].type=J2K_MS_RGN;
- img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos=cio_tell()-2;
- img.marker_mul.RGN[img.marker_mul.num_RGN].len=len;
+ img.marker_mul.RGN = (info_marker_t*)malloc(img.marker_mul.CzRGN * sizeof(info_marker_t));
+ if (img.marker_mul.num_RGN >= img.marker_mul.CzRGN)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzRGN) * sizeof(info_marker_t));
+ memcpy(tmp,img.marker_mul.RGN, img.marker_mul.CzRGN);
+ img.marker_mul.CzRGN += INCREMENT;
+ free(img.marker_mul.RGN);
+ img.marker_mul.RGN = tmp;
+ }
+ img.marker_mul.RGN[img.marker_mul.num_RGN].type = J2K_MS_RGN;
+ img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos = cio_tell() - 2;
+ img.marker_mul.RGN[img.marker_mul.num_RGN].len = len;
img.marker_mul.num_RGN++;
+ } else
+ {
+ tile = &img.tile[j2k_curtileno];
+ if (!tile->marker_mul.num_RGN)
+ tile->marker_mul.RGN = (info_marker_t*)malloc(tile->marker_mul.CzRGN * sizeof(info_marker_t));
+ if (tile->marker_mul.num_RGN >= tile->marker_mul.CzRGN)
+ {
+ tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzRGN) * sizeof(info_marker_t));
+ memcpy(tmp,tile->marker_mul.RGN,tile->marker_mul.CzRGN);
+ tile->marker_mul.CzRGN += INCREMENT;
+ free(tile->marker_mul.RGN);
+ tile->marker_mul.RGN = tmp;
+ }
+
+ tile->marker_mul.RGN[tile->marker_mul.num_RGN].type = J2K_MS_RGN;
+ tile->marker_mul.RGN[tile->marker_mul.num_RGN].start_pos = cio_tell() - 2;
+ tile->marker_mul.RGN[tile->marker_mul.num_RGN].len = len;
+ tile->marker_mul.num_RGN++;
}
- // </INDEX>
+ /* </INDEX> [MHIX BOX] */
+
+ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);
+ roisty = cio_read(1);
+ tcp->tccps[compno].roishift = cio_read(1);
+}
+
+
+
+
+void j2k_read_sod() {
+ int len;
+ unsigned char *data;
+ info_tile_t *tile;
+ info_tile_part_t *tile_part;
+ // fprintf(stderr,"SOD\n");
+ /* <INDEX> [MHIX BOX] */
+ tile = &img.tile[j2k_curtileno];
+ tile->marker[tile->num_marker].type = J2K_MS_SOD;
+ tile->marker[tile->num_marker].start_pos = cio_tell();
+ tile->marker[tile->num_marker].len = 0;
+ tile->num_marker++;
+ /* </INDEX> [MHIX BOX] */
+
+ tile_part = &tile->tile_parts[tile->numparts - 1]; /* INDEX : Current tilepart of a tile */
+ tile_part->length_header = cio_tell() - 1 - tile_part->start_pos; /* INDEX : length of the tile-part header */
+ tile_part->end_header = cio_tell() - 1; /* INDEX : end header position of the tile-part header */
+
+ len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft());
- compno=cio_read(j2k_img->numcomps<=256?1:2);
- roisty=cio_read(1);
- tcp->tccps[compno].roishift=cio_read(1);
+ j2k_tile_len[j2k_curtileno] += len;
+ data = (unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
+ memcpy(data, cio_getbp(), len);
+ j2k_tile_data[j2k_curtileno] = data;
+ cio_skip(len);
+ j2k_state = J2K_STATE_TPHSOT;
}
void j2k_read_eoc() {
int tileno;
tcd_init(j2k_img, j2k_cp, &img);
- for (tileno=0; tileno<j2k_cp->tw*j2k_cp->th; tileno++) {
+ for (tileno = 0; tileno<j2k_cp->tw * j2k_cp->th; tileno++) {
tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno, &img);
}
- j2k_state=J2K_STATE_MT;
+ j2k_state = J2K_STATE_MT;
longjmp(j2k_error, 1);
-
}
+
+
+
void j2k_read_unk() {
fprintf(stderr, "warning: unknown marker\n");
}
-int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len){
+
+
+
+int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len, int version){
FILE *dest;
char *index;
int pos_iptr, end_pos;
dest=fopen(Idx_file, "wb");
if (!dest) {
- fprintf(stderr,"Failed to open %s for reading !!\n",Idx_file);
+ fprintf(stderr, "Failed to open %s for reading !!\n", Idx_file);
return 0;
}
- // INDEX MODE JPIP
- index=(char*)malloc(len);
+ /* INDEX MODE JPIP */
+ index = (char*)malloc(len);
cio_init(index, len);
jp2_write_jp();
jp2_write_ftyp();
jp2_write_dbtl(Idx_file);
pos_iptr=cio_tell();
- cio_skip(24); // IPTR further !
+ cio_skip(24); /* IPTR further ! */
- pos_jp2c=cio_tell();
- len_jp2c=jp2_write_jp2c(J2K_file);
-
- pos_cidx=cio_tell();
- len_cidx=jpip_write_cidx(pos_jp2c+8,img, j2k_cp); // Correction len_jp2C --> pos_jp2c+8
-
- pos_fidx=cio_tell();
- len_fidx=jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
+ pos_jp2c = cio_tell();
+ len_jp2c = jp2_write_jp2c(J2K_file);
+
+ pos_cidx = cio_tell();
+ len_cidx = jpip_write_cidx(pos_jp2c + 8,img, j2k_cp, version); /* Correction len_jp2C --> pos_jp2c + 8 */
+
- end_pos=cio_tell();
+ pos_fidx = cio_tell();
+ len_fidx = jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
+
+end_pos = cio_tell();
+
cio_seek(pos_iptr);
jpip_write_iptr(pos_fidx,len_fidx);
cio_seek(end_pos);
-
+
fwrite(index, 1, cio_tell(), dest);
free(index);
j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
j2k_dec_mstabent_t *e;
- for (e=j2k_dec_mstab; e->id!=0; e++) {
- if (e->id==id) {
+ for (e = j2k_dec_mstab; e->id != 0; e++) {
+ if (e->id == id) {
break;
}
}
return e;
}
-LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
+int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
if (setjmp(j2k_error)) {
- if (j2k_state!=J2K_STATE_MT) {
+ if (j2k_state != J2K_STATE_MT) {
fprintf(stderr, "WARNING: incomplete bitstream\n");
return 0;
}
return cio_numbytes();
}
- j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
- j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
- *image=j2k_img;
- *cp=j2k_cp;
- j2k_state=J2K_STATE_MHSOC;
+ j2k_img = (j2k_image_t*)calloc(1, sizeof(j2k_image_t));
+ j2k_cp = (j2k_cp_t*)calloc(1, sizeof(j2k_cp_t));
+ *image = j2k_img;
+ *cp = j2k_cp;
+ j2k_state = J2K_STATE_MHSOC;
cio_init(src, len);
for (;;) {
j2k_dec_mstabent_t *e;
- int id=cio_read(2);
- if (id>>8!=0xff) {
- fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id);
+ int id = cio_read(2);
+ if (id >> 8 != 0xff) {
+ fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell() - 2, id);
return 0;
}
- e=j2k_dec_mstab_lookup(id);
+ e = j2k_dec_mstab_lookup(id);
if (!(j2k_state & e->states)) {
- fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id);
+ fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
return 0;
}
if (e->handler) {
}
+
#ifdef WIN32
#include <windows.h>
}
#endif
-
-extern info_image_t img;
-
-
int main(int argc, char **argv)
{
FILE *src;
char *j2kfile;
j2k_image_t *imgg;
j2k_cp_t *cp;
+ int version;
- if (argc!=3)
+ if (argc != 4)
{
- fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file\n\n");
- return 0;
+ fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file version\n\nVersion : 0, 1, 2 or 3\n\n");
+ return 1;
}
src=fopen(argv[1], "rb");
if (!src) {
- fprintf(stderr,"Failed to open %s for reading !!\n",argv[1]);
- return 0;
+ fprintf(stderr, "Failed to open %s for reading !!\n", argv[1]);
+ return 1;
}
- // length of the codestream
+ /* length of the codestream */
fseek(src, 0, SEEK_END);
- totlen=ftell(src);
+ totlen = ftell(src);
fseek(src, 0, SEEK_SET);
- j2kfile=(char*)malloc(totlen);
+ j2kfile = (char*)malloc(totlen);
fread(j2kfile, 1, totlen, src);
-
- img.marker=(info_marker_t*)malloc(32*sizeof(info_marker_t));
- img.num_marker=0;
- img.marker_mul.num_COD=0;
- img.marker_mul.num_COC=0;
- img.marker_mul.num_RGN=0;
- img.marker_mul.num_QCC=0;
- img.marker_mul.num_TLM=0;
- img.marker_mul.num_PLM=0;
- img.marker_mul.num_COM=0;
-
- // decode
+ fclose(src);
+
+ img.marker = (info_marker_t*)malloc(32 * sizeof(info_marker_t));
+ img.num_marker = 0;
+ img.num_max_tile_parts = 0;
+ img.marker_mul.num_COC = 0;
+ img.marker_mul.CzCOC = START_NB;
+ img.marker_mul.num_RGN = 0;
+ img.marker_mul.CzRGN = START_NB;
+ img.marker_mul.num_QCC = 0;
+ img.marker_mul.CzQCC = START_NB;
+ img.marker_mul.num_TLM = 0;
+ img.marker_mul.CzTLM = START_NB;
+ img.marker_mul.num_PLM = 0;
+ img.marker_mul.CzPLM = START_NB;
+ img.marker_mul.num_PPM = 0;
+ img.marker_mul.CzPPM = START_NB;
+ img.marker_mul.num_COM = 0;
+ img.marker_mul.CzCOM = START_NB;
+
+ /* decode */
if (!j2k_decode(j2kfile, totlen, &imgg, &cp)) {
fprintf(stderr, "Index_creator: failed to decode image!\n");
return 1;
}
-
free(j2kfile);
+
+ // fseek(src, 0, SEEK_SET);
+ img.codestream_size = totlen;
+ sscanf(argv[3], "%d", &version);
+ if (version > 3)
+ {
+ fprintf(stderr,"Error : value of version unauthorized !! Value accepted : 0, 1, 2 or 3 !!\n");
+ return 0;
+ }
- fseek(src, 0, SEEK_SET);
- img.codestream_size=totlen;
-
- j2k_index_JPIP(argv[2],argv[1],totlen*2>30000?totlen*2:30000);
-
- fclose(src);
-
+ j2k_index_JPIP(argv[2], argv[1], totlen * 2 > 60000 ? totlen * 2 : 60000, version);
+
j2k_clean();
- return 1;
+ return 0;
}
+
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
typedef struct
{
- int dx, dy; // XRsiz, YRsiz
- int prec; // precision
- int bpp; // deapth of image in bits
- int sgnd; // signed
- int *data; // image-component data
+ int dx, dy; /* XRsiz, YRsiz */
+ int prec; /* precision */
+ int bpp; /* deapth of image in bits */
+ int sgnd; /* signed */
+ int *data; /* image-component data */
} j2k_comp_t;
typedef struct {
- int x0, y0; // XOsiz, YOsiz
- int x1, y1; // Xsiz, Ysiz
- int numcomps; // number of components
- int index_on; // 0 = no index || 1 = index
- //int PPT;
- j2k_comp_t *comps; // image-components
+ int version;
+ int x0, y0; /* XOsiz, YOsiz */
+ int x1, y1; /* Xsiz, Ysiz */
+ int numcomps; /* number of components */
+ int index_on; /* 0 = no index || 1 = index */
+ j2k_comp_t *comps; /* image-components */
} j2k_image_t;
typedef struct {
- int expn; // exponent
- int mant; // mantissa
+ int expn; /* exponent */
+ int mant; /* mantissa */
} j2k_stepsize_t;
typedef struct {
- int csty; // coding style
- int numresolutions; // number of resolutions
- int cblkw; // width of code-blocks
- int cblkh; // height of code-blocks
- int cblksty; // code-block coding style
- int qmfbid; // discrete wavelet transform identifier
- int qntsty; // quantisation style
- j2k_stepsize_t stepsizes[J2K_MAXBANDS]; // stepsizes used for quantisation
- int numgbits; // number of guard bits
- int roishift; // Region Of Interest shift
- int prcw[J2K_MAXRLVLS]; // Precinct width
- int prch[J2K_MAXRLVLS]; // Precinct height
+ int csty; /* coding style */
+ int numresolutions; /* number of resolutions */
+ int cblkw; /* width of code-blocks */
+ int cblkh; /* height of code-blocks */
+ int cblksty; /* code-block coding style */
+ int qmfbid; /* discrete wavelet transform identifier */
+ int qntsty; /* quantisation style */
+ j2k_stepsize_t stepsizes[J2K_MAXBANDS]; /* stepsizes used for quantisation */
+ int numgbits; /* number of guard bits */
+ int roishift; /* Region of Interest shift */
+ int prcw[J2K_MAXRLVLS]; /* Precinct width */
+ int prch[J2K_MAXRLVLS]; /* Precinct height */
} j2k_tccp_t;
typedef struct {
} j2k_poc_t;
typedef struct {
- int csty; // coding style
- int prg; // progression order
- int numlayers; // number of layers
- int mct; // multi-component transform identifier
- int rates[100]; // rates of layers
- int numpocs; // number of progression order changes
- j2k_poc_t pocs[32]; // progression order changes
- j2k_tccp_t *tccps; // tile-component coding parameters
+ //int first;
+ int csty; /* coding style */
+ int prg; /* progression order */
+ int numlayers; /* number of layers */
+ int mct; /* multi-component transform identifier */
+ int rates[100]; /* rates of layers */
+ int numpocs; /* number of progression order changes */
+ int POC; /* Precise if a POC marker has been used O:NO, 1:YES */
+ j2k_poc_t pocs[32]; /* progression order changes */
+ unsigned char *ppt_data; /* packet header store there for futur use in t2_decode_packet */
+ int ppt; /* If ppt == 1 --> there was a PPT marker for the present tile */
+ int ppt_store; /* Use in case of multiple marker PPT (number of info already store) */
+ j2k_tccp_t *tccps; /* tile-component coding parameters */
} j2k_tcp_t;
typedef struct {
- int tx0, ty0; // XTOsiz, YTOsiz
- int tdx, tdy; // XTsiz, YTsiz
- int tw, th;
- j2k_tcp_t *tcps; // tile coding parameters
+ int tx0, ty0; /* XTOsiz, YTOsiz */
+ int tdx, tdy; /* XTsiz, YTsiz */
+ int tw, th;
+ unsigned char *ppm_data; /* packet header store there for futur use in t2_decode_packet */
+ int ppm; /* If ppm == 1 --> there was a PPM marker for the present tile */
+ int ppm_store; /* Use in case of multiple marker PPM (number of info already store) */
+ int ppm_previous; /* Use in case of multiple marker PPM (case on non-finished previous info) */
+ j2k_tcp_t *tcps; /* tile coding parameters */
} j2k_cp_t;
+
+
+
+
+/* Packet information : Layer level */
typedef struct {
- int len;
- int len_header;
- int offset;
+ int len; /* Length of the body of the packet */
+ int len_header; /* Length of the header of the packet */
+ int offset; /* Offset of the body of the packet */
+ int offset_header; /* Offset of the header of the packet */
} info_layer_t;
+
+/* Access to packet information : precinct level */
typedef struct {
info_layer_t *layer;
} info_prec_t;
+
+/* Access to packet information : resolution level */
typedef struct {
info_prec_t *prec;
} info_reso_t;
+
+/* Access to packet information : component level */
typedef struct {
info_reso_t *reso;
} info_compo_t;
+
+/* Information about the marker */
typedef struct {
- int num_tile; // Number of Tile
- int start_pos; // Start position
- int end_header; // End position of the header
- int end_pos; // End position
- int pw, ph; // number of precinct by tile
- int num_packet; // number of packet in the tile
- info_compo_t *compo; // component [packet]
-} info_tile_t; // index struct
+ int type; /* type of marker [SIZ, QCD, POC, PPM, CRG, COD] appearing only once */
+ int start_pos; /* Start position of the marker */
+ int len; /* Length of the marker */
+} info_marker_t;
+
+/* Multiple marker in tile header */
+typedef struct{
+ info_marker_t *COC; /* COC markers */
+ int num_COC; /* Number of COC marker */
+ int CzCOC; /* Current size of the vector COC */
+
+ info_marker_t *RGN; /* RGN markers */
+ int num_RGN; /* Number of RGN marker */
+ int CzRGN; /* Current size of the vector RGN */
+
+ info_marker_t *QCC; /* QCC markers */
+ int num_QCC; /* Number of QCC marker */
+ int CzQCC; /* Current size of the vector QCC */
+
+ info_marker_t *PLT; /* PLT markers */
+ int num_PLT; /* Number of PLT marker */
+ int CzPLT; /* Current size of the vector PLT */
+
+ info_marker_t *PPT; /* PPT markers */
+ int num_PPT; /* Number of PPT marker */
+ int CzPPT; /* Current size of the vector PPT */
+
+ info_marker_t *COM; /* COM markers */
+ int num_COM; /* Number of COM marker */
+ int CzCOM; /* Current size of the vector COC */
+} info_marker_mul_tile_t;
+
+
+/* Information about each tile_part for a particulary tile */
+typedef struct{
+ int start_pos; /* Start position of the tile_part */
+ int length; /* Length of the tile_part header + body */
+ int length_header; /* Length of the header */
+ int end_pos; /* End position of the tile part */
+ int end_header; /* End position of the tile part header */
+
+ int num_reso_AUX; /* Number of resolution level completed */
+} info_tile_part_t;
+
+
+/* Information about each tile */
typedef struct {
- int type; // type of marker [SIZ, QCD, POC, PPM, CRG] appearing only once
- int start_pos; // Start position of the marker
- int len; // Length of the marker
-} info_marker_t; // index struct
+ int num_tile; /* Number of Tile */
+ int pw, ph; /* number of precinct by tile */
+ int num_packet; /* number of packet in the tile */
+ info_compo_t *compo; /* component [packet] */
+
+ info_marker_t *marker; /* information concerning markers inside image [only one apparition] */
+ info_marker_mul_tile_t marker_mul; /* information concerning markers inside image [multiple apparition] */
+ int num_marker; /* number of marker */
+
+ int numparts; /* number of tile_part for this tile */
+ info_tile_part_t *tile_parts; /* Information about each tile_part */
+ int Cztile_parts; /* Current size of the tile_parts vector */
+} info_tile_t; /* index struct */
+
+/* Multiple marker in main header */
typedef struct{
- info_marker_t *COD;
- int num_COD;
- info_marker_t *COC;
- int num_COC;
- info_marker_t *RGN;
- int num_RGN;
- info_marker_t *QCC;
- int num_QCC;
- info_marker_t *TLM;
- int num_TLM;
- info_marker_t *PLM;
- int num_PLM;
- info_marker_t *PPM;
- int num_PPM;
- info_marker_t *COM;
- int num_COM;
-} info_marker_mul_t; // index struct
+ info_marker_t *COC; /* COC markers */
+ int num_COC; /* Number of COC marker */
+ int CzCOC; /* Current size of the vector COC */
+
+ info_marker_t *RGN; /* RGN markers */
+ int num_RGN; /* Number of RGN marker */
+ int CzRGN; /* Current size of the vector RGN */
+
+ info_marker_t *QCC; /* QCC markers */
+ int num_QCC; /* Number of QCC marker */
+ int CzQCC; /* Current size of the vector QCC */
+
+ info_marker_t *TLM; /* TLM markers */
+ int num_TLM; /* Number of TLM marker */
+ int CzTLM; /* Current size of the vector TLM */
+
+ info_marker_t *PLM; /* PLM markers */
+ int num_PLM; /* Number of PLM marker */
+ int CzPLM; /* Current size of the vector PLM */
+
+ info_marker_t *PPM; /* PPM markers */
+ int num_PPM; /* Number of PPM marker */
+ int CzPPM; /* Current size of the vector PPM */
+
+ info_marker_t *COM; /* COM markers */
+ int num_COM; /* Number of COM marker */
+ int CzCOM; /* Current size of the vector COM */
+} info_marker_mul_t; /* index struct */
+
+/* Information about image */
typedef struct {
- int index_on;
- int num; // numero of packet
- int index_write; // writing the packet inthe index with t2_encode_packets
- int Im_w, Im_h; // Image width and Height
- int Prog; // progression order
- int Tile_x, Tile_y; // Number of Tile in X and Y
+ int Im_w, Im_h; /* Image width and Height */
+ int Tile_x, Tile_y; /* Number of Tile in X and Y */
int tw, th;
- int Comp; // Component numbers
- int Layer; // number of layer
- int Decomposition; // number of decomposition
- int pw, ph; // nombre precinct in X and Y
- int pdx, pdy; // size of precinct in X and Y
- int Main_head_end; // Main header position
- int codestream_size; // codestream's size
- info_tile_t *tile; // information concerning tiles inside image
- info_marker_t *marker; // information concerning markers inside image [only one apparition]
- info_marker_mul_t marker_mul; // information concerning markers inside image [multiple apparition]
- int num_marker; // number of marker
- int num_packet_max; // MAximum number of packet
-} info_image_t; // index struct
-
-
-
-/*
- * Encode an image into a JPEG-2000 codestream
- * i: image to encode
- * cp: coding parameters
- * dest: destination buffer
- * len: length of destination buffer
- * index : index file name
- */
-LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,char *outfile, int len,char *index);
+ int pw, ph; /* nombre precinct in X and Y */
+ int pdx, pdy; /* size of precinct in X and Y */
+
+ int Prog; /* progression order */
+ int Comp; /* Component numbers */
+ int Layer; /* number of layer */
+ int Decomposition; /* number of decomposition */
+
+ int Main_head_end; /* Main header position */
+ int codestream_size; /* codestream's size */
+
+ info_marker_t *marker; /* information concerning markers inside image [only one apparition] */
+ info_marker_mul_t marker_mul; /* information concerning markers inside image [multiple apparition] */
+ int num_marker; /* number of marker */
+
+ int num_packet_max; /* Maximum number of packet */
+
+ int num_max_tile_parts; /* Maximum number of tile-part */
+ info_tile_t *tile; /* information concerning tiles inside image */
+} info_image_t; /* index struct */
-//LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len);
-/*
- * Decode an image from a JPEG-2000 codestream
- * src: source buffer
- * len: length of source buffer
- * i: decode image
- * cp: coding parameters that were used to encode the image
- */
-LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **i, j2k_cp_t **cp);
#endif
/*
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <setjmp.h>
-#include <math.h>
-#include <unistd.h>
#include "j2k.h"
#include "cio.h"
cio_seek(lenp+len);
}
+/*
+ * Write the JP2H box
+ *
+ * JP2 Header box
+ *
+ */
void jp2_write_jp2h(j2k_image_t *j2k_img)
{
int len, lenp, BPC_ok;
lenp=cio_tell();
cio_skip(4);
- cio_write(JP2_JP2H, 4); // JP2H
+ cio_write(JP2_JP2H, 4); /* JP2H */
BPC_ok=jp2_write_ihdr(j2k_img);
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len,4); // L
+ cio_write(len,4); /* L */
cio_seek(lenp+len);
}
+/*
+ * Write the FTYP box
+ *
+ * File type box
+ *
+ */
void jp2_write_ftyp()
{
int len, lenp;
lenp=cio_tell();
cio_skip(4);
- cio_write(JP2_FTYP, 4); // FTYP
+ cio_write(JP2_FTYP, 4); /* FTYP */
- cio_write(JP2,4); // BR
- cio_write(0,4); // MinV
- cio_write(JP2,4); // CL0 : JP2
- cio_write(JPIP_JPIP,4); // CL1 : JPIP
+ cio_write(JP2,4); /* BR */
+ cio_write(0,4); /* MinV */
+ cio_write(JP2,4); /* CL0 : JP2 */
+ cio_write(JPIP_JPIP,4); /* CL1 : JPIP */
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len,4); // L
+ cio_write(len,4); /* L */
cio_seek(lenp+len);
}
+/*
+ * Read the FTYP box
+ *
+ * File type box
+ *
+ */
+void jp2_read_ftyp(int length)
+{
+ int BR, MinV, type, i;
+
+ BR = cio_read(4); /* BR */
+ MinV = cio_read(4); /* MinV */
+ length-=8;
+
+ for (i=length/4;i>0;i--)
+ type = cio_read(4); /* CLi : JP2, JPIP */
+}
+
int jp2_write_jp2c(char *J2K_file)
{
int len, lenp, totlen, i;
cio_write(len,4); // L
cio_seek(lenp+len);
}
+
+/*
+ * Read the JP box
+ *
+ * JPEG 2000 signature
+ *
+ * return 1 if error else 0
+ */
+int jp2_read_jp()
+{
+ if (0x0d0a870a!=cio_read(4))
+ return 1;
+ else
+ return 0;
+}
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
+#ifndef __JP2_H
+#define __JP2_H
#include "j2k.h"
int jp2_write_jp2c(char *J2K_file);
void jp2_write_jp();
+
+#endif
/*
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include "tcd.h"
#include "int.h"
-#define JPIP_CIDX 0x63696478
-#define JPIP_CPTR 0x63707472
-#define JPIP_MANF 0x6d616e66
-#define JPIP_FAIX 0x66616978
-#define JPIP_MHIX 0x6d686978
-#define JPIP_TPIX 0x74706978
-#define JPIP_THIX 0x74686978
-#define JPIP_PPIX 0x70706978
-#define JPIP_PHIX 0x70686978
-#define JPIP_FIDX 0x66696478
-#define JPIP_FPTR 0x66707472
-#define JPIP_PRXY 0x70727879
-#define JPIP_IPTR 0x69707472
+#define JPIP_CIDX 0x63696478 /* Codestream index */
+#define JPIP_CPTR 0x63707472 /* Codestream Finder Box */
+#define JPIP_MANF 0x6d616e66 /* Manifest Box */
+#define JPIP_FAIX 0x66616978 /* Fragment array Index box */
+#define JPIP_MHIX 0x6d686978 /* Main Header Index Table */
+#define JPIP_TPIX 0x74706978 /* Tile-part Index Table box */
+#define JPIP_THIX 0x74686978 /* Tile header Index Table box */
+#define JPIP_PPIX 0x70706978 /* Precinct Packet Index Table box */
+#define JPIP_PHIX 0x70686978 /* Packet Header index Table */
+#define JPIP_FIDX 0x66696478 /* File Index */
+#define JPIP_FPTR 0x66707472 /* File Finder */
+#define JPIP_PRXY 0x70727879 /* Proxy boxes */
+#define JPIP_IPTR 0x69707472 /* Index finder box */
+#define JPIP_PHLD 0x70686c64 /* Place holder */
#define JP2C 0x6a703263
-static info_marker_t marker_jpip[32], marker_local_jpip[32]; // SIZE to precise !
-static int num_marker_jpip, num_marker_local_jpip;
+//static info_marker_t marker_jpip[32], marker_local_jpip[32]; /* SIZE to precise ! */
+//static int num_marker_jpip, num_marker_local_jpip;
-void jpip_write_cptr(int offset, info_image_t img) // Codestream finder box (box)
+/*
+ * Write the CPTR box
+ *
+ * Codestream finder box (box)
+ *
+ */
+void jpip_write_cptr(int offset, info_image_t img)
{
int len, lenp;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_CPTR,4); // T
- cio_write(0,2); // DR A PRECISER !!
- cio_write(0,2); // CONT
- cio_write(offset,8); // COFF A PRECISER !!
- cio_write(img.codestream_size,8); // CLEN
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_CPTR,4); /* T */
+ cio_write(0,2); /* DR A PRECISER !! */
+ cio_write(0,2); /* CONT */
+ cio_write(offset,8); /* COFF A PRECISER !! */
+ cio_write(img.codestream_size,8); /* CLEN */
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
-void jpip_write_manf(int second, int v, info_marker_t *marker) // Manifest box (box)
+/*
+ * Read the CPTR box
+ *
+ * Codestream finder box (box)
+ *
+ */
+void jpip_read_cptr()
+{
+ int DR, CONT;
+ long long Coff, codestream_size;
+
+ DR = cio_read(2); /* DR */
+ CONT = cio_read(2); /* CONT */
+ Coff = cio_read(8); /* COFF */
+ codestream_size = cio_read(8); /* CLEN */
+}
+
+/*
+ * Write the MANF box
+ *
+ * Manifest box (box)
+ *
+ */
+void jpip_write_manf(int second, int v, info_marker_t *marker)
{
int len, lenp, i;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_MANF,4); // T
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_MANF,4); /* T */
- if (second) // Write only during the second pass
+ if (second) /* Write only during the second pass */
{
for(i=0;i<v;i++)
{
- cio_write(marker[i].len,4);
- cio_write(marker[i].type,4);
+ cio_write(marker[i].len,4); /* Marker length */
+ cio_write(marker[i].type,4); /* Marker type */
}
}
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
-int jpip_write_mhix(info_image_t img) // Main Header Index Table (box)
+/*
+ * Read the MANF box
+ *
+ * Manifest box (box)
+ *
+ */
+void jpip_read_manf(int len)
{
- int len, lenp, i;
- lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_MHIX, 4); // CIDX
-
- cio_write(img.Main_head_end,8); // TLEN
+ int i, v, marker_len, marker_type;
- for(i=0;i<img.num_marker;i++) // Marker restricted to 1 apparition
- {
- cio_write(img.marker[i].type,2);
- cio_write(0,2);
- cio_write(img.marker[i].start_pos,8);
- cio_write(img.marker[i].len,2);
- }
-
- // Marker NOT restricted to 1 apparition
- for(i=img.marker_mul.num_COD-1;i>=0;i--) // COD
+ v = (len - 8)/ 8;
+
+ for(i=0;i<v;i++)
{
- cio_write(img.marker_mul.COD[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.COD[i].start_pos,8);
- cio_write(img.marker_mul.COD[i].len,2);
+ marker_len = cio_read(4); /* Marker length */
+ marker_type = cio_read(4); /* Marker type */
}
+}
- for(i=img.marker_mul.num_COC-1;i>=0;i--) // COC
- {
- cio_write(img.marker_mul.COC[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.COC[i].start_pos,8);
- cio_write(img.marker_mul.COC[i].len,2);
- }
+/*
+ * Write the MHIX box
+ *
+ * Main Header Index Table (box)
+ *
+ */
+int jpip_write_mhix(info_image_t img, int status, int tileno)
+{
+ int len, lenp, i;
+ info_tile_t *tile;
+ lenp=cio_tell();
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_MHIX, 4); /* MHIX */
- for(i=img.marker_mul.num_RGN-1;i>=0;i--) // RGN
+ if (status) /* MAIN HEADER */
{
- cio_write(img.marker_mul.RGN[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.RGN[i].start_pos,8);
- cio_write(img.marker_mul.RGN[i].len,2);
- }
+ cio_write(img.Main_head_end,8); /* TLEN */
+
+ for(i = 0; i < img.num_marker; i++) /* Marker restricted to 1 apparition */
+ {
+ cio_write(img.marker[i].type, 2);
+ cio_write(0, 2);
+ cio_write(img.marker[i].start_pos, 8);
+ cio_write(img.marker[i].len, 2);
+ }
+
+ /* Marker NOT restricted to 1 apparition */
+ for(i = img.marker_mul.num_COC - 1; i >= 0; i--) /* COC */
+ {
+ cio_write(img.marker_mul.COC[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.COC[i].start_pos, 8);
+ cio_write(img.marker_mul.COC[i].len, 2);
+ }
+
+ for(i = img.marker_mul.num_RGN - 1; i >= 0; i--) /* RGN */
+ {
+ cio_write(img.marker_mul.RGN[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.RGN[i].start_pos, 8);
+ cio_write(img.marker_mul.RGN[i].len, 2);
+ }
+
+ for(i = img.marker_mul.num_QCC - 1; i >= 0; i--) /* QCC */
+ {
+ cio_write(img.marker_mul.QCC[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.QCC[i].start_pos, 8);
+ cio_write(img.marker_mul.QCC[i].len, 2);
+ }
+
+ for(i = img.marker_mul.num_TLM - 1; i >= 0; i--) /* TLM */
+ {
+ cio_write(img.marker_mul.TLM[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.TLM[i].start_pos, 8);
+ cio_write(img.marker_mul.TLM[i].len, 2);
+ }
+
+ for(i = img.marker_mul.num_PLM - 1; i >= 0; i--) /* PLM */
+ {
+ cio_write(img.marker_mul.PLM[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.PLM[i].start_pos, 8);
+ cio_write(img.marker_mul.PLM[i].len, 2);
+ }
+
+ for(i = img.marker_mul.num_PPM - 1; i >= 0; i--) /* PPM */
+ {
+ cio_write(img.marker_mul.PPM[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.PPM[i].start_pos, 8);
+ cio_write(img.marker_mul.PPM[i].len, 2);
+ }
- for(i=img.marker_mul.num_QCC-1;i>=0;i--) // QCC
+ for(i = img.marker_mul.num_COM - 1; i >= 0; i--) /* COM */
+ {
+ cio_write(img.marker_mul.COM[i].type, 2);
+ cio_write(i, 2);
+ cio_write(img.marker_mul.COM[i].start_pos, 8);
+ cio_write(img.marker_mul.COM[i].len, 2);
+ }
+ }
+ else /* TILE HEADER */
{
- cio_write(img.marker_mul.QCC[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.QCC[i].start_pos,8);
- cio_write(img.marker_mul.QCC[i].len,2);
- }
+ tile = &img.tile[tileno];
+ cio_write(tile->tile_parts[0].length_header, 8); /* TLEN */
+
+ for(i = 0; i < tile->num_marker; i++) /* Marker restricted to 1 apparition */
+ {
+ cio_write(tile->marker[i].type, 2);
+ cio_write(0, 2);
+ cio_write(tile->marker[i].start_pos, 8);
+ cio_write(tile->marker[i].len, 2);
+ }
+
+ /* Marker NOT restricted to 1 apparition */
+ for(i = tile->marker_mul.num_COC - 1; i >= 0; i--) /* COC */
+ {
+ cio_write(tile->marker_mul.COC[i].type, 2);
+ cio_write(i, 2);
+ cio_write(tile->marker_mul.COC[i].start_pos, 8);
+ cio_write(tile->marker_mul.COC[i].len, 2);
+ }
+
+ for(i = tile->marker_mul.num_RGN - 1; i >= 0; i--) /* RGN */
+ {
+ cio_write(tile->marker_mul.RGN[i].type, 2);
+ cio_write(i, 2);
+ cio_write(tile->marker_mul.RGN[i].start_pos, 8);
+ cio_write(tile->marker_mul.RGN[i].len, 2);
+ }
+
+ for(i = tile->marker_mul.num_QCC - 1; i >= 0; i--) /* QCC */
+ {
+ cio_write(tile->marker_mul.QCC[i].type, 2);
+ cio_write(i, 2);
+ cio_write(tile->marker_mul.QCC[i].start_pos, 8);
+ cio_write(tile->marker_mul.QCC[i].len, 2);
+ }
+
+ for(i = tile->marker_mul.num_PLT - 1; i >= 0; i--) /* PLT */
+ {
+ cio_write(tile->marker_mul.PLT[i].type,2);
+ cio_write(i,2);
+ cio_write(tile->marker_mul.PLT[i].start_pos,8);
+ cio_write(tile->marker_mul.PLT[i].len,2);
+ }
+
+ for(i = tile->marker_mul.num_PPT - 1; i >= 0; i--) /* PPT */
+ {
+ cio_write(tile->marker_mul.PPT[i].type, 2);
+ cio_write(i, 2);
+ cio_write(tile->marker_mul.PPT[i].start_pos, 8);
+ cio_write(tile->marker_mul.PPT[i].len, 2);
+ }
+
+ for(i = tile->marker_mul.num_COM - 1; i >= 0; i--) /* COM */
+ {
+ cio_write(tile->marker_mul.COM[i].type, 2);
+ cio_write(i, 2);
+ cio_write(tile->marker_mul.COM[i].start_pos, 8);
+ cio_write(tile->marker_mul.COM[i].len, 2);
+ }
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); /* L */
+ cio_seek(lenp+len);
+
+ return len;
+}
- for(i=img.marker_mul.num_TLM-1;i>=0;i--) // TLM
- {
- cio_write(img.marker_mul.TLM[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.TLM[i].start_pos,8);
- cio_write(img.marker_mul.TLM[i].len,2);
- }
+/*
+ * Read the MHIX box
+ *
+ * Main Header Index Table (box)
+ *
+ */
+void jpip_read_mhix(int len)
+{
+ int i, v, marker_type, marker_start_pos, marker_len, marker_remains;
- for(i=img.marker_mul.num_PLM-1;i>=0;i--) // PLM
- {
- cio_write(img.marker_mul.PLM[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.PLM[i].start_pos,8);
- cio_write(img.marker_mul.PLM[i].len,2);
- }
+ v = (len - 8) / 14;
- for(i=img.marker_mul.num_COM-1;i>=0;i--) // COM
+ for (i=0; i<v ; i++)
{
- cio_write(img.marker_mul.COM[i].type,2);
- cio_write(i,2);
- cio_write(img.marker_mul.COM[i].start_pos,8);
- cio_write(img.marker_mul.COM[i].len,2);
+ marker_type = cio_read(2); /* Type of the marker */
+ marker_remains = cio_read(2); /* Number of same markers following */
+ marker_start_pos = cio_read(2); /* Start position of the marker */
+ marker_len = cio_read(2); /* Length of the marker */
}
-
- len=cio_tell()-lenp;
- cio_seek(lenp);
- cio_write(len, 4); // L
- cio_seek(lenp+len);
-
- return len;
}
-int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp) // Fragment array Index box
+/*
+ * Write the FAIX box
+ *
+ * Fragment array Index box (box)
+ *
+ */
+int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp, int version)
{
- int len, lenp, i;
- int version = 0;
+ int len, lenp, i, j;
+ /*int version = 0;*/
int tileno, resno, precno, layno, num_packet=0;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_FAIX, 4); // MHIX
- cio_write(version,1); // Version 0 = 4 bytes
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_FAIX, 4); /* FAIX */
+ cio_write(version,1); /* Version 0 = 4 bytes */
switch(v)
{
- case 0: // TPIX
- cio_write(1,version?8:4); // NMAX
- cio_write(img.tw*img.th,version?8:4); // M
- for (i=0;i<img.tw*img.th;i++)
+ case 0: /* TPIX */
+ cio_write(img.num_max_tile_parts,(version & 0x01)?8:4); /* NMAX */
+ cio_write(img.tw*img.th,(version & 0x01)?8:4); /* M */
+ for (i = 0; i < img.tw*img.th; i++)
{
- cio_write(img.tile[i].start_pos,version?8:4);
- cio_write(img.tile[i].end_pos-img.tile[i].start_pos,version?8:4);
+ for (j = 0; j < img.tile[i].numparts ; j++)
+ {
+ cio_write(img.tile[i].tile_parts[j].start_pos,(version & 0x01)?8:4); /* start position */
+ cio_write(img.tile[i].tile_parts[j].length,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4); /* Aux_i,j : Auxiliary value */
+ //cio_write(0,4);
+ }
+ /* PADDING */
+ while (j < img.num_max_tile_parts)
+ {
+ cio_write(0,(version & 0x01)?8:4); /* start position */
+ cio_write(0,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(0,4); /* Aux_i,j : Auxiliary value */
+ j++;
+ }
}
break;
- case 1: // THIX
- cio_write(1,version?8:4); // NMAX
- cio_write(img.tw*img.th,version?8:4); // M
- for (i=0;i<img.tw*img.th;i++)
- {
- cio_write(img.tile[i].start_pos,version?8:4);
- cio_write(img.tile[i].end_header-img.tile[i].start_pos,version?8:4);
- }
- break;
-
- case 2: // PPIX NOT FINISHED !!
- cio_write(img.num_packet_max,version?8:4); // NMAX
- cio_write(img.tw*img.th,version?8:4); // M
+ /* case 1: */ /* THIX */
+ /* cio_write(1,(version & 0x01)?8:4); */ /* NMAX */
+ /* cio_write(img.tw*img.th,(version & 0x01)?8:4); */ /* M */
+ /* for (i=0;i<img.tw*img.th;i++) */
+ /* { */
+ /* cio_write(img.tile[i].start_pos,(version & 0x01)?8:4); */ /* start position */
+ /* cio_write(img.tile[i].end_header-img.tile[i].start_pos,(version & 0x01)?8:4); */ /* length */
+ /* if (version & 0x02)*/
+ /* cio_write(0,4); */ /* Aux_i,j : Auxiliary value */
+ /* } */
+ /* break; */
+
+ case 2: /* PPIX NOT FINISHED !! */
+ cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
+ cio_write(img.tw*img.th,(version & 0x01)?8:4); /* M */
for(tileno=0;tileno<img.tw*img.th;tileno++)
{
info_tile_t *tile_Idx = &img.tile[tileno];
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
int correction;
+
+ num_packet=0;
+
if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
correction=3;
else
for(layno=0;layno<img.Layer;layno++)
{
info_layer_t *layer_Idx = &prec_Idx->layer[layno];
- cio_write(layer_Idx->offset,version?8:4);
- cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,version?8:4);
+ cio_write(layer_Idx->offset,(version & 0x01)?8:4); /* start position */
+ cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
}
+ /* PADDING */
+ while (num_packet < img.num_packet_max)
+ {
+ cio_write(0,(version & 0x01)?8:4); /* start position */
+ cio_write(0,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(0,4); /* Aux_i,j : Auxiliary value */
+ num_packet++;
+ }
}
- // PADDING
- while (num_packet<img.num_packet_max)
- {
- cio_write(0,version?8:4);
- cio_write(0,version?8:4);
- num_packet++;
- }
+
break;
- case 3: // PHIX NOT FINISHED !!
- cio_write(img.num_packet_max,version?8:4); // NMAX
- cio_write(img.tw*img.th,version?8:4); // M
+ case 3: /* PHIX NOT FINISHED !! */
+ cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
+ cio_write(img.tw*img.th,(version & 0x01)?8:4); /* M */
for(tileno=0;tileno<img.tw*img.th;tileno++)
{
info_tile_t *tile_Idx = &img.tile[tileno];
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
int correction;
+
+ num_packet = 0;
if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
correction=3;
else
for(layno=0;layno<img.Layer;layno++)
{
info_layer_t *layer_Idx = &prec_Idx->layer[layno];
- cio_write(layer_Idx->offset,version?8:4);
- cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,version?8:4);
+ cio_write(layer_Idx->offset_header,(version & 0x01)?8:4); /* start position */
+ cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
}
- }
- // PADDING
- while (num_packet<img.num_packet_max)
- {
- cio_write(0,version?8:4);
- cio_write(0,version?8:4);
- num_packet++;
+ /* PADDING */
+ while (num_packet<img.num_packet_max)
+ {
+ cio_write(0,(version & 0x01)?8:4); /* start position */
+ cio_write(0,(version & 0x01)?8:4); /* length */
+ if (version & 0x02)
+ cio_write(0,4); /* Aux_i,j : Auxiliary value */
+ num_packet++;
+ }
}
break;
}
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
}
-int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp) // Tile-part Index Table box (superbox)
+/*
+ * Write the TPIX box
+ *
+ * Tile-part Index table box (superbox)
+ *
+ */
+int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp, int version)
{
int len, lenp;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_TPIX, 4); // TPIX
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_TPIX, 4); /* TPIX */
- jpip_write_faix(0,0,img, j2k_cp);
+ jpip_write_faix(0,0,img, j2k_cp, version);
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
}
-int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp) // Tile header Index Table box (superbox)
-{
- int len, lenp;
- lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_THIX, 4); // THIX
+/*
+ * Write the THIX box
+ *
+ * Tile header Index table box (superbox)
+ *
+ */
+//int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp)
+// {
+// int len, lenp;
+// lenp=cio_tell();
+// cio_skip(4); /* L [at the end] */
+// cio_write(JPIP_THIX, 4); /* THIX */
- jpip_write_faix(1,0,img, j2k_cp);
+// jpip_write_faix(1,0,img, j2k_cp);
- len=cio_tell()-lenp;
- cio_seek(lenp);
- cio_write(len, 4); // L
- cio_seek(lenp+len);
+// len=cio_tell()-lenp;
+// cio_seek(lenp);
+// cio_write(len, 4); /* L */
+// cio_seek(lenp+len);
+
+// return len;
+//}
+
+int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp)
+{
+ int len, lenp, i;
+ int tileno;
+ info_marker_t *marker;
+ int num_marker_local_jpip;
+
+ marker = (info_marker_t*)calloc(sizeof(info_marker_t), j2k_cp->tw*j2k_cp->th);
+
+ for ( i = 0; i < 2 ; i++ )
+ {
+ if (i) cio_seek(lenp);
+
+ lenp = cio_tell();
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_THIX, 4); /* THIX */
+ jpip_write_manf(i, j2k_cp->tw*j2k_cp->th, marker);
+ num_marker_local_jpip=img.Comp;
+
+ for (tileno = 0; tileno < j2k_cp->tw*j2k_cp->th; tileno++)
+ {
+ marker[tileno].len = jpip_write_mhix(img, 1, tileno);
+ marker[tileno].type = JPIP_MHIX;
+ }
+
+ len=cio_tell()-lenp;
+ cio_seek(lenp);
+ cio_write(len, 4); /* L */
+ cio_seek(lenp+len);
+ }
+
+ free(marker);
return len;
}
-
-int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp) // Precinct Packet Index Table box (superbox)
+/*
+ * Write the PPIX box
+ *
+ * Precinct Packet Index table box (superbox)
+ *
+ */
+int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp)
{
int len, lenp, compno, i;
+ info_marker_t *marker;
+ int num_marker_local_jpip;
+ marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
for (i=0;i<2;i++)
{
if (i) cio_seek(lenp);
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_PPIX, 4); // PPIX
- jpip_write_manf(i,img.Comp,marker_local_jpip);
-
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_PPIX, 4); /* PPIX */
+ jpip_write_manf(i,img.Comp,marker);
num_marker_local_jpip=img.Comp;
for (compno=0; compno<img.Comp; compno++)
{
- marker_local_jpip[compno].len=jpip_write_faix(2,compno,img, j2k_cp);
- marker_local_jpip[compno].type=JPIP_FAIX;
+ marker[compno].len=jpip_write_faix(2,compno,img, j2k_cp, 0);
+ marker[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
+
+ free(marker);
+
return len;
-}
+}
-int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp) // Packet Header Index Table Box (superbox)
+/*
+ * Write the PHIX box
+ *
+ * Packet Header Index table box (superbox)
+ *
+ */
+int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp)
{
int len, lenp=0, compno, i;
-
+ info_marker_t *marker;
+
+ marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
+
for (i=0;i<2;i++)
{
if (i) cio_seek(lenp);
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_PHIX, 4); // PHIX
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_PHIX, 4); /* PHIX */
- jpip_write_manf(i,img.Comp,marker_local_jpip);
+ jpip_write_manf(i,img.Comp,marker);
for (compno=0; compno<img.Comp; compno++)
{
- marker_local_jpip[compno].len=jpip_write_faix(3,compno,img, j2k_cp);
- marker_local_jpip[compno].type=JPIP_FAIX;
+ marker[compno].len=jpip_write_faix(3,compno,img, j2k_cp, 0);
+ marker[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
+
+ free(marker);
+
return len;
}
-int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp) // Codestream index box (superbox)
+/*
+ * Write the CIDX box
+ *
+ * Codestream Index box (superbox)
+ *
+ */
+int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp, int version)
{
- int len, lenp=0, i;
- num_marker_jpip=0;
+ int len, lenp = 0, i;
+ info_marker_t *marker_jpip;
+ int num_marker_jpip = 0;
+
+ marker_jpip = (info_marker_t*)calloc(sizeof(info_marker_t), 32);
for (i=0;i<2;i++)
{
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_CIDX, 4); // CIDX
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_CIDX, 4); /* CIDX */
jpip_write_cptr(offset, img);
- jpip_write_manf(i,num_marker_jpip, marker_jpip); // A definir
+
+ jpip_write_manf(i,num_marker_jpip, marker_jpip);
num_marker_jpip=0;
- marker_jpip[num_marker_jpip].len=jpip_write_mhix(img);
+ marker_jpip[num_marker_jpip].len=jpip_write_mhix(img, 0, 0);
marker_jpip[num_marker_jpip].type=JPIP_MHIX;
num_marker_jpip++;
- marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp);
+ marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp, version);
marker_jpip[num_marker_jpip].type=JPIP_TPIX;
num_marker_jpip++;
-
+
marker_jpip[num_marker_jpip].len=jpip_write_thix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_THIX;
num_marker_jpip++;
-
+
marker_jpip[num_marker_jpip].len=jpip_write_ppix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_PPIX;
num_marker_jpip++;
-
+
marker_jpip[num_marker_jpip].len=jpip_write_phix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_PHIX;
num_marker_jpip++;
-
+
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
-
+
+ free(marker_jpip);
+
return len;
}
+/*
+ * Write the IPTR box
+ *
+ * Index Finder box
+ *
+ */
void jpip_write_iptr(int offset, int length)
{
int len, lenp;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_IPTR, 4); // IPTR
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_IPTR, 4); /* IPTR */
cio_write(offset,8);
cio_write(length,8);
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
+/*
+ * Write the PRXY box
+ *
+ * proxy (box)
+ *
+ */
void jpip_write_prxy(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
{
int len, lenp;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_PRXY, 4); // IPTR
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_PRXY, 4); /* IPTR */
- cio_write(offset_jp2c,8); // OOFF
- cio_write(length_jp2c,4); // OBH part 1
- cio_write(JP2C,4); // OBH part 2
+ cio_write(offset_jp2c,8); /* OOFF */
+ cio_write(length_jp2c,4); /* OBH part 1 */
+ cio_write(JP2C,4); /* OBH part 2 */
- cio_write(1,1); // NI
+ cio_write(1,1); /* NI */
- cio_write(offset_idx,8); // IOFF
- cio_write(length_idx,4); // IBH part 1
- cio_write(JPIP_CIDX,4); // IBH part 2
+ cio_write(offset_idx,8); /* IOFF */
+ cio_write(length_idx,4); /* IBH part 1 */
+ cio_write(JPIP_CIDX,4); /* IBH part 2 */
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
-}
+}
+
+/*
+ * Write the FIDX box
+ *
+ * File Index (superbox)
+ *
+ */
int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
{
int len, lenp;
lenp=cio_tell();
- cio_skip(4); // L [at the end]
- cio_write(JPIP_FIDX, 4); // IPTR
+ cio_skip(4); /* L [at the end] */
+ cio_write(JPIP_FIDX, 4); /* IPTR */
jpip_write_prxy(offset_jp2c, length_jp2c, offset_idx, offset_jp2c);
len=cio_tell()-lenp;
cio_seek(lenp);
- cio_write(len, 4); // L
+ cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003-2004, Yannick Verschueren
+ * Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
-
+
#include "pi.h"
#include "int.h"
#include <stdlib.h>
#include <stdio.h>
-
-/// <summary>
-/// Create a packet iterator.
-/// </summary>
-pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno) {
- int p, q;
- int compno, resno,pino, layno, precno;
- int maxres=0;
- pi_iterator_t *pi;
- j2k_tcp_t *tcp;
- j2k_tccp_t *tccp;
-
- tcp=&cp->tcps[tileno];
- pi=(pi_iterator_t*)malloc((tcp->numpocs+1)*sizeof(pi_iterator_t));
-
- for (pino=0;pino<tcp->numpocs+1;pino++) // change
- {
- p=tileno%cp->tw;
- q=tileno/cp->tw;
-
- pi[pino].tx0=int_max(cp->tx0+p*cp->tdx, img->x0);
- pi[pino].ty0=int_max(cp->ty0+q*cp->tdy, img->y0);
- pi[pino].tx1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
- pi[pino].ty1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
- pi[pino].numcomps=img->numcomps;
- pi[pino].comps=(pi_comp_t*)malloc(img->numcomps*sizeof(pi_comp_t));
-
- for (compno=0; compno<pi->numcomps; compno++)
- {
- int tcx0, tcy0, tcx1, tcy1;
- pi_comp_t *comp=&pi[pino].comps[compno];
-
- tccp=&tcp->tccps[compno];
- comp->dx=img->comps[compno].dx;
- comp->dy=img->comps[compno].dy;
- comp->numresolutions=tccp->numresolutions;
- comp->resolutions=(pi_resolution_t*)malloc(comp->numresolutions*sizeof(pi_resolution_t));
- tcx0=int_ceildiv(pi->tx0, comp->dx);
- tcy0=int_ceildiv(pi->ty0, comp->dy);
- tcx1=int_ceildiv(pi->tx1, comp->dx);
- tcy1=int_ceildiv(pi->ty1, comp->dy);
- if (comp->numresolutions>maxres) {
- maxres=comp->numresolutions;
- }
- for (resno=0; resno<comp->numresolutions; resno++)
- {
- int levelno;
- int rx0, ry0, rx1, ry1;
- int px0, py0, px1, py1;
- pi_resolution_t *res=&comp->resolutions[resno];
- if (tccp->csty&J2K_CCP_CSTY_PRT) {
- res->pdx=tccp->prcw[resno];
- res->pdy=tccp->prch[resno];
+
+/* <summary> */
+/* Create a packet iterator. */
+/* </summary> */
+pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno)
+{
+ int p, q;
+ int compno, resno, pino;
+ int maxres = 0;
+ pi_iterator_t *pi;
+ j2k_tcp_t *tcp;
+ j2k_tccp_t *tccp;
+
+ tcp = &cp->tcps[tileno];
+ pi = (pi_iterator_t *) malloc((tcp->numpocs + 1) * sizeof(pi_iterator_t));
+
+ for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */
+ p = tileno % cp->tw;
+ q = tileno / cp->tw;
+
+ pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, img->x0);
+ pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, img->y0);
+ pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);
+ pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);
+ pi[pino].numcomps = img->numcomps;
+ pi[pino].comps = (pi_comp_t *) malloc(img->numcomps * sizeof(pi_comp_t));
+
+ for (compno = 0; compno < pi->numcomps; compno++) {
+ int tcx0, tcy0, tcx1, tcy1;
+ pi_comp_t *comp = &pi[pino].comps[compno];
+ tccp = &tcp->tccps[compno];
+ comp->dx = img->comps[compno].dx;
+ comp->dy = img->comps[compno].dy;
+ comp->numresolutions = tccp->numresolutions;
+ comp->resolutions =
+ (pi_resolution_t *) malloc(comp->numresolutions *
+ sizeof(pi_resolution_t));
+ tcx0 = int_ceildiv(pi->tx0, comp->dx);
+ tcy0 = int_ceildiv(pi->ty0, comp->dy);
+ tcx1 = int_ceildiv(pi->tx1, comp->dx);
+ tcy1 = int_ceildiv(pi->ty1, comp->dy);
+ if (comp->numresolutions > maxres) {
+ maxres = comp->numresolutions;
+ }
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ int levelno;
+ int rx0, ry0, rx1, ry1;
+ int px0, py0, px1, py1;
+ pi_resolution_t *res = &comp->resolutions[resno];
+ if (tccp->csty & J2K_CCP_CSTY_PRT) {
+ res->pdx = tccp->prcw[resno];
+ res->pdy = tccp->prch[resno];
+ } else {
+ res->pdx = 15;
+ res->pdy = 15;
+ }
+ levelno = comp->numresolutions - 1 - resno;
+ rx0 = int_ceildivpow2(tcx0, levelno);
+ ry0 = int_ceildivpow2(tcy0, levelno);
+ rx1 = int_ceildivpow2(tcx1, levelno);
+ ry1 = int_ceildivpow2(tcy1, levelno);
+ px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
+ py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
+ px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
+ py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
+ res->pw = (px1 - px0) >> res->pdx;
+ res->ph = (py1 - py0) >> res->pdy;
+ }
+ }
+
+ tccp = &tcp->tccps[0];
+ pi[pino].step_p=1;
+ pi[pino].step_c=100*pi[pino].step_p;
+ pi[pino].step_r=img->numcomps*pi[pino].step_c;
+ pi[pino].step_l=maxres*pi[pino].step_r;
+
+ if (pino==0)
+ pi[pino].include=(short int*)calloc(img->numcomps*maxres*tcp->numlayers*100,sizeof(short int));
+ else
+ pi[pino].include=pi[pino-1].include;
+
+ /*if (pino == tcp->numpocs) {*/
+ if (tcp->POC == 0) {
+ pi[pino].first = 1;
+ pi[pino].poc.resno0 = 0;
+ pi[pino].poc.compno0 = 0;
+ pi[pino].poc.layno1 = tcp->numlayers;
+ pi[pino].poc.resno1 = maxres;
+ pi[pino].poc.compno1 = img->numcomps;
+ pi[pino].poc.prg = tcp->prg;
} else {
- res->pdx=15;
- res->pdy=15;
+ pi[pino].first = 1;
+ pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
+ pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
+ pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
+ pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
+ pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
+ pi[pino].poc.prg = tcp->pocs[pino].prg;
}
- levelno=comp->numresolutions-1-resno;
- rx0=int_ceildivpow2(tcx0, levelno);
- ry0=int_ceildivpow2(tcy0, levelno);
- rx1=int_ceildivpow2(tcx1, levelno);
- ry1=int_ceildivpow2(tcy1, levelno);
- px0=int_floordivpow2(rx0, res->pdx)<<res->pdx;
- py0=int_floordivpow2(ry0, res->pdy)<<res->pdy;
- px1=int_ceildivpow2(rx1, res->pdx)<<res->pdx;
- py1=int_ceildivpow2(ry1, res->pdy)<<res->pdy;
- res->pw=(px1-px0)>>res->pdx;
- res->ph=(py1-py0)>>res->pdy;
- }
- }
-
- for (layno=0; layno<10; layno++)
- {
- for (resno=0; resno<10; resno++)
- {
- for (compno=0; compno<3; compno++)
- {
- for (precno=0; precno<99; precno++)
- {
- pi[pino].include[layno][resno][compno][precno]=0;
- }
- }
- }
- }
-
- if (pino==tcp->numpocs)
- {
- pi[pino].first=1;
- pi[pino].poc.resno0=0;
- pi[pino].poc.compno0=0;
- pi[pino].poc.layno1=tcp->numlayers;
- pi[pino].poc.resno1=maxres;
- pi[pino].poc.compno1=img->numcomps;
- pi[pino].poc.prg=tcp->prg;
- } else
- {
- pi[pino].first=1;
- pi[pino].poc.resno0=tcp->pocs[pino].resno0;
- pi[pino].poc.compno0=tcp->pocs[pino].compno0;
- pi[pino].poc.layno1=tcp->pocs[pino].layno1;
- pi[pino].poc.resno1=tcp->pocs[pino].resno1;
- pi[pino].poc.compno1=tcp->pocs[pino].compno1;
- pi[pino].poc.prg=tcp->pocs[pino].prg;
- }
- }
- return pi;
+ }
+ return pi;
}
-/// <summary>
-/// Get next packet in layer=resolution-component-precinct order.
-/// </summary>
-int pi_next_lrcp(pi_iterator_t *pi) {
- pi_comp_t *comp;
- pi_resolution_t *res;
-
- if (!pi->first)
- {
- comp=&pi->comps[pi->compno];
- res=&comp->resolutions[pi->resno];
- goto skip;
- } else {
- pi->first=0;
- }
- for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++)
- {
- for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++)
- {
- for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++)
- {
-
- comp=&pi->comps[pi->compno];
- if (pi->resno>=comp->numresolutions)
- {
-
- continue;
- }
- res=&comp->resolutions[pi->resno];
+/* <summary> */
+/* Get next packet in layer=resolution-component-precinct order. */
+/* </summary> */
+int pi_next_lrcp(pi_iterator_t * pi)
+{
+ pi_comp_t *comp;
+ pi_resolution_t *res;
- for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++)
- {
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ res = &comp->resolutions[pi->resno];
+ goto skip;
+ } else {
+ pi->first = 0;
+ }
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
+ pi->resno++) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;
+ pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
- if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
- {
- pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
- return 1;
- }
- skip: ;
- }
- }
- }
- }
- return 0;
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {
+ if (!pi->include[pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p]){
+ pi->include[pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p] = 1;
+ return 1;
+ }
+ skip:;
+ }
+ }
+ }
+ }
+ return 0;
}
-/// <summary>
-/// Get next packet in resolution-layer-component-precinct order.
-/// </summary>
-int pi_next_rlcp(pi_iterator_t *pi) {
- pi_comp_t *comp;
- pi_resolution_t *res;
- if (!pi->first) {
- comp=&pi->comps[pi->compno];
- res=&comp->resolutions[pi->resno];
- goto skip;
- } else {
- pi->first=0;
- }
- for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++) {
- for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
- for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
- comp=&pi->comps[pi->compno];
- if (pi->resno>=comp->numresolutions) {
- continue;
- }
- res=&comp->resolutions[pi->resno];
- for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++) {
- if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
- {
- pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
- return 1;
- }
- skip: ;
- }
- }
- }
- }
- return 0;
+/* <summary> */
+/* Get next packet in resolution-layer-component-precinct order. */
+/* </summary> */
+int pi_next_rlcp(pi_iterator_t * pi)
+{
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ res = &comp->resolutions[pi->resno];
+ goto skip;
+ } else {
+ pi->first = 0;
+ }
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;
+ pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {
+ if (!pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
+ pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 1;
+ return 1;
+ }
+ skip:;
+ }
+ }
+ }
+ }
+ return 0;
}
-/// <summary>
-/// Get next packet in resolution-precinct-component-layer order.
-/// </summary>
-int pi_next_rpcl(pi_iterator_t *pi) {
- pi_comp_t *comp;
- pi_resolution_t *res;
- if (!pi->first) {
- goto skip;
- } else {
- int compno, resno;
- pi->first=0;
- pi->dx=0;
- pi->dy=0;
- for (compno=0; compno<pi->numcomps; compno++) {
- comp=&pi->comps[compno];
- for (resno=0; resno<comp->numresolutions; resno++) {
- int dx, dy;
- res=&comp->resolutions[resno];
- dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
- dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
- pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
- pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
- }
- }
- }
- for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++) {
- for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
- for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
- for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
- int levelno;
- int trx0, try0;
- int rpx, rpy;
- int prci, prcj;
- comp=&pi->comps[pi->compno];
- if (pi->resno>=comp->numresolutions) {
- continue;
- }
- res=&comp->resolutions[pi->resno];
- levelno=comp->numresolutions-1-pi->resno;
- trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
- try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
- rpx=res->pdx+levelno;
- rpy=res->pdy+levelno;
- if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
- continue;
- }
- if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
- continue;
- }
- prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
- prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
- pi->precno=prci+prcj*res->pw;
- for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
- if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
- {
- pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
- return 1;
- }
- skip: ;
- }
- }
- }
- }
- }
- return 0;
+/* <summary> */
+/* Get next packet in resolution-precinct-component-layer order. */
+/* </summary> */
+int pi_next_rpcl(pi_iterator_t * pi)
+{
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ goto skip;
+ } else {
+ int compno, resno;
+ pi->first = 0;
+ pi->dx = 0;
+ pi->dy = 0;
+ for (compno = 0; compno < pi->numcomps; compno++) {
+ comp = &pi->comps[compno];
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ int dx, dy;
+ res = &comp->resolutions[resno];
+ dx =
+ comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy =
+ comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+ }
+ }
+ }
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+ for (pi->y = pi->ty0; pi->y < pi->ty1;
+ pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->tx0; pi->x < pi->tx1;
+ pi->x += pi->dx - (pi->x % pi->dx)) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;
+ pi->compno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!
+ (pi->x % (comp->dx << rpx) == 0
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ if (!
+ (pi->y % (comp->dy << rpy) == 0
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ prci =
+ int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
+ res->pdx) - int_floordivpow2(trx0, res->pdx);
+ prcj =
+ int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
+ res->pdy) - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ if (!pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
+ pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 1;
+ return 1;
+ }
+ skip:;
+ }
+ }
+ }
+ }
+ }
+ return 0;
}
-/// <summary>
-/// Get next packet in precinct-component-resolution-layer order.
-/// </summary>
-int pi_next_pcrl(pi_iterator_t *pi) {
- pi_comp_t *comp;
- pi_resolution_t *res;
- if (!pi->first) {
- comp=&pi->comps[pi->compno];
- goto skip;
- } else {
- int compno, resno;
- pi->first=0;
- pi->dx=0;
- pi->dy=0;
- for (compno=0; compno<pi->numcomps; compno++) {
- comp=&pi->comps[compno];
- for (resno=0; resno<comp->numresolutions; resno++) {
- int dx, dy;
- res=&comp->resolutions[resno];
- dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
- dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
- pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
- pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
- }
- }
- }
- for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
- for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
- for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
- comp=&pi->comps[pi->compno];
- for (pi->resno=pi->poc.resno0; pi->resno<int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
- int levelno;
- int trx0, try0;
- int rpx, rpy;
- int prci, prcj;
- res=&comp->resolutions[pi->resno];
- levelno=comp->numresolutions-1-pi->resno;
- trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
- try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
- rpx=res->pdx+levelno;
- rpy=res->pdy+levelno;
- if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
- continue;
- }
- if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
- continue;
- }
- prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
- prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
- pi->precno=prci+prcj*res->pw;
- for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
- if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
- {
- pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
- return 1;
+/* <summary> */
+/* Get next packet in precinct-component-resolution-layer order. */
+/* </summary> */
+int pi_next_pcrl(pi_iterator_t * pi)
+{
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ goto skip;
+ } else {
+ int compno, resno;
+ pi->first = 0;
+ pi->dx = 0;
+ pi->dy = 0;
+ for (compno = 0; compno < pi->numcomps; compno++) {
+ comp = &pi->comps[compno];
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ int dx, dy;
+ res = &comp->resolutions[resno];
+ dx =
+ comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy =
+ comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
}
- skip: ;
- }
- }
- }
- }
- }
- return 0;
+ }
+ }
+ for (pi->y = pi->ty0; pi->y < pi->ty1;
+ pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->tx0; pi->x < pi->tx1;
+ pi->x += pi->dx - (pi->x % pi->dx)) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;
+ pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ for (pi->resno = pi->poc.resno0;
+ pi->resno < int_min(pi->poc.resno1, comp->numresolutions);
+ pi->resno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!
+ (pi->x % (comp->dx << rpx) == 0
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ if (!
+ (pi->y % (comp->dy << rpy) == 0
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ prci =
+ int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
+ res->pdx) - int_floordivpow2(trx0, res->pdx);
+ prcj =
+ int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
+ res->pdy) - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ if (! pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
+ pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 1;
+ return 1;
+ }
+ skip:;
+ }
+ }
+ }
+ }
+ }
+ return 0;
}
-/// <summary>
-/// Get next packet in component-precinct-resolution-layer order.
-/// </summary>
-int pi_next_cprl(pi_iterator_t *pi) {
- pi_comp_t *comp;
- pi_resolution_t *res;
- if (!pi->first) {
- comp=&pi->comps[pi->compno];
- goto skip;
- } else {
- pi->first=0;
- }
- for (pi->compno=pi->poc.compno0; pi->compno<pi->poc.compno1; pi->compno++) {
- int resno;
- comp=&pi->comps[pi->compno];
- pi->dx=0;
- pi->dy=0;
- for (resno=0; resno<comp->numresolutions; resno++) {
- int dx, dy;
- res=&comp->resolutions[resno];
- dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
- dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
- pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
- pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
- }
- for (pi->y=pi->ty0; pi->y<pi->ty1; pi->y+=pi->dy-(pi->y%pi->dy)) {
- for (pi->x=pi->tx0; pi->x<pi->tx1; pi->x+=pi->dx-(pi->x%pi->dx)) {
- for (pi->resno=pi->poc.resno0; pi->resno<int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
- int levelno;
- int trx0, try0;
- int rpx, rpy;
- int prci, prcj;
- res=&comp->resolutions[pi->resno];
- levelno=comp->numresolutions-1-pi->resno;
- trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
- try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
- rpx=res->pdx+levelno;
- rpy=res->pdy+levelno;
- if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
- continue;
- }
- if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
- continue;
- }
- prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
- prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
- pi->precno=prci+prcj*res->pw;
- for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
- if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
- {
- pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
- return 1;
+/* <summary> */
+/* Get next packet in component-precinct-resolution-layer order. */
+/* </summary> */
+int pi_next_cprl(pi_iterator_t * pi)
+{
+ pi_comp_t *comp;
+ pi_resolution_t *res;
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ goto skip;
+ } else {
+ pi->first = 0;
+ }
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1;
+ pi->compno++) {
+ int resno;
+ comp = &pi->comps[pi->compno];
+ pi->dx = 0;
+ pi->dy = 0;
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ int dx, dy;
+ res = &comp->resolutions[resno];
+ dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+ }
+ for (pi->y = pi->ty0; pi->y < pi->ty1;
+ pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->tx0; pi->x < pi->tx1;
+ pi->x += pi->dx - (pi->x % pi->dx)) {
+ for (pi->resno = pi->poc.resno0;
+ pi->resno < int_min(pi->poc.resno1, comp->numresolutions);
+ pi->resno++) {
+ int levelno;
+ int trx0, try0;
+ int rpx, rpy;
+ int prci, prcj;
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!
+ (pi->x % (comp->dx << rpx) == 0
+ || (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ if (!
+ (pi->y % (comp->dy << rpy) == 0
+ || (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
+ continue;
+ }
+ prci =
+ int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
+ res->pdx) - int_floordivpow2(trx0, res->pdx);
+ prcj =
+ int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
+ res->pdy) - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
+ if (! pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
+ pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 1;
+ return 1;
+ }
+ skip:;
+ }
+ }
}
- skip: ;
- }
- }
- }
- }
- }
- return 0;
+ }
+ }
+ return 0;
}
-/// <summary>
-/// Get next packet.
-/// </summary>
-int pi_next(pi_iterator_t *pi) {
- switch (pi->poc.prg) {
- case 0:
- return pi_next_lrcp(pi);
- case 1:
- return pi_next_rlcp(pi);
- case 2:
- return pi_next_rpcl(pi);
- case 3:
- return pi_next_pcrl(pi);
- case 4:
- return pi_next_cprl(pi);
- }
+/* <summary> */
+/* Get next packet. */
+/* </summary> */
+int pi_next(pi_iterator_t * pi)
+{
+ switch (pi->poc.prg) {
+ case 0:
+ return pi_next_lrcp(pi);
+ case 1:
+ return pi_next_rlcp(pi);
+ case 2:
+ return pi_next_rpcl(pi);
+ case 3:
+ return pi_next_pcrl(pi);
+ case 4:
+ return pi_next_cprl(pi);
+ }
return 0;
}
/*
* Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include "tcd.h"
typedef struct {
- int pdx, pdy;
- int pw, ph;
+ int pdx, pdy;
+ int pw, ph;
} pi_resolution_t;
typedef struct {
- int dx, dy;
- int numresolutions;
- pi_resolution_t *resolutions;
+ int dx, dy;
+ int numresolutions;
+ pi_resolution_t *resolutions;
} pi_comp_t;
typedef struct {
- int include[10][10][3][99];
- int compno, resno, precno, layno; // component, resolution, precinct and layer that indentify the packet
- int first;
- j2k_poc_t poc;
- int numcomps;
- pi_comp_t *comps;
- int tx0, ty0, tx1, ty1;
- int x, y, dx, dy;
-} pi_iterator_t; // packet iterator
+ short int *include;
+ int step_l, step_r, step_c, step_p;
+ int compno, resno, precno, layno; /* component, resolution, precinct and layer that indentify the packet */
+ int first;
+ j2k_poc_t poc;
+ int numcomps;
+ pi_comp_t *comps;
+ int tx0, ty0, tx1, ty1;
+ int x, y, dx, dy;
+} pi_iterator_t; /* packet iterator */
/*
* Create a packet iterator
* tileno: number that identifies the tile for which to list the packets
* return value: returns a packet iterator that points to the first packet of the tile
*/
-pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno);
+pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno);
/*
* Modify the packet iterator to point to the next packet
* pi: packet iterator to modify
* return value: returns 0 if pi pointed to the last packet or else returns 1
*/
-int pi_next(pi_iterator_t *pi);
+int pi_next(pi_iterator_t * pi);
#endif
seg->maxpasses=cblksty&J2K_CCP_CBLKSTY_TERMALL?1:100;
}
-int t2_decode_packet(unsigned char *src, int len, tcd_tile_t *tile, j2k_tcp_t *tcp, int compno, int resno, int precno, int layno, info_layer_t *layer_Idx) {
+int t2_decode_packet(unsigned char *src, int len, tcd_tile_t *tile, j2k_cp_t * cp, j2k_tcp_t *tcp, int compno, int resno, int precno, int layno, info_layer_t *layer_Idx) {
int bandno, cblkno;
- tcd_tilecomp_t *tilec=&tile->comps[compno];
- tcd_resolution_t *res=&tilec->resolutions[resno];
- unsigned char *c=src;
- unsigned char *d=c;
+ tcd_tilecomp_t *tilec = &tile->comps[compno];
+ tcd_resolution_t *res = &tilec->resolutions[resno];
+ unsigned char *c = src;
+ unsigned char *d = c;
int e;
int present;
- if (layno==0) {
- for (bandno=0; bandno<res->numbands; bandno++) {
- tcd_band_t *band=&res->bands[bandno];
- tcd_precinct_t *prc=&band->precincts[precno];
+ if (layno == 0) {
+ for (bandno = 0; bandno < res->numbands; bandno++) {
+ tcd_band_t *band = &res->bands[bandno];
+ tcd_precinct_t *prc = &band->precincts[precno];
tgt_reset(prc->incltree);
tgt_reset(prc->imsbtree);
- for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
- tcd_cblk_t *cblk=&prc->cblks[cblkno];
- cblk->numsegs=0;
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];
+ cblk->numsegs = 0;
}
}
}
+ /* INDEX */
+ layer_Idx->len_header = 0;
- if (tcp->csty&J2K_CP_CSTY_SOP) {
- c+=6;
- }
- bio_init_dec(c, src+len-c);
- present=bio_read(1);
- if (!present) {
- bio_inalign();
- c+=bio_numbytes();
- return c-src;
- }
+ /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
+ This part deal with this caracteristic
+ step 1: Read packet header in the saved structure
+ step 2: (futher) return to codestream for decoding */
+ if (cp->ppm == 1) /* PPM */
+ {
+ c = cp->ppm_data;
+ d = c;
+ bio_init_dec(c, 1000);
+ } else
+ {
+ if (tcp->ppt == 1) /* PPT */
+ {
+ c = tcp->ppt_data;
+ d = c;
+ bio_init_dec(c, 1000);
+ } else /* Normal Case */
+ {
+ if (tcp->csty & J2K_CP_CSTY_SOP)
+ {
+ if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [1]!!!\n");}
+ c += 6;
+ }
+ bio_init_dec(c, src + len - c);
+ layer_Idx->len_header = -6;
+ }
+ }
+
+ present = bio_read(1);
+
+ if (!present)
+ {
+ bio_inalign();
+ /* Normal case */
+ c += bio_numbytes();
+ if (tcp->csty & J2K_CP_CSTY_EPH)
+ {
+ if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [1]!!!\n");}
+ c += 2;
+ }
+ /* INDEX */
+ layer_Idx->len_header += (c-d);
+
+ /* PPT and PPM dealing */
+ if (cp->ppm == 1) /* PPM */
+ {
+ cp->ppm_data = c;
+ return 0;
+ }
+ if (tcp->ppt == 1) /* PPT */
+ {
+ tcp->ppt_data = c;
+ return 0;
+ }
+ return c - src;
+ }
+
for (bandno=0; bandno<res->numbands; bandno++) {
- tcd_band_t *band=&res->bands[bandno];
- tcd_precinct_t *prc=&band->precincts[precno];
- for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
+ tcd_band_t *band = &res->bands[bandno];
+ tcd_precinct_t *prc = &band->precincts[precno];
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
int included, increment, n;
- tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_seg_t *seg;
if (!cblk->numsegs) {
- included=tgt_decode(prc->incltree, cblkno, layno+1);
+ included = tgt_decode(prc->incltree, cblkno, layno+1);
} else {
- included=bio_read(1);
+ included = bio_read(1);
}
if (!included) {
- cblk->numnewpasses=0;
+ cblk->numnewpasses = 0;
continue;
}
if (!cblk->numsegs) {
int i, numimsbs;
- for (i=0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {}
- numimsbs=i-1;
- cblk->numbps=band->numbps-numimsbs;
- cblk->numlenbits=3;
+ for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {}
+ numimsbs = i-1;
+ cblk->numbps = band->numbps - numimsbs;
+ cblk->numlenbits = 3;
}
- cblk->numnewpasses=t2_getnumpasses();
- increment=t2_getcommacode();
- cblk->numlenbits+=increment;
+ cblk->numnewpasses = t2_getnumpasses();
+ increment = t2_getcommacode();
+ cblk->numlenbits += increment;
if (!cblk->numsegs) {
- seg=&cblk->segs[0];
+ seg = &cblk->segs[0];
t2_init_seg(seg, tcp->tccps[compno].cblksty);
} else {
- seg=&cblk->segs[cblk->numsegs-1];
- if (seg->numpasses==seg->maxpasses) {
+ seg = &cblk->segs[cblk->numsegs - 1];
+ if (seg->numpasses == seg->maxpasses) {
t2_init_seg(++seg, tcp->tccps[compno].cblksty);
}
}
- n=cblk->numnewpasses;
+ n = cblk->numnewpasses;
do {
- seg->numnewpasses=int_min(seg->maxpasses-seg->numpasses, n);
- seg->newlen=bio_read(cblk->numlenbits+int_floorlog2(seg->numnewpasses));
- n-=seg->numnewpasses;
- if (n>0) {
+ seg->numnewpasses = int_min(seg->maxpasses-seg->numpasses, n);
+ seg->newlen = bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses));
+ n -= seg->numnewpasses;
+ if (n > 0) {
t2_init_seg(++seg, tcp->tccps[compno].cblksty);
}
- } while (n>0);
+ } while (n > 0);
}
}
if(bio_inalign()) return -999;
- c+=bio_numbytes();
- if (tcp->csty&J2K_CP_CSTY_EPH) {
- c+=2;
+ c += bio_numbytes();
+
+ if (tcp->csty & J2K_CP_CSTY_EPH) { /* EPH marker */
+ if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [2]!!!\n"); }
+ c += 2;
}
+
+ /* INDEX */
+ layer_Idx->len_header += (c-d);
+
+ /* PPT Step 2 : see above for details */
+ if (cp->ppm == 1)
+ {
+ cp->ppm_data = c; /* Update pointer */
- // INDEX
- layer_Idx->len_header=c-d;
- if (tcp->csty&J2K_CP_CSTY_SOP)
- layer_Idx->len_header-=6;
- // \INDEX --> END OF HEADER !!
+ /* INDEX */
+ layer_Idx->len_header = c-d;
- for (bandno=0; bandno<res->numbands; bandno++) {
- tcd_band_t *band=&res->bands[bandno];
- tcd_precinct_t *prc=&band->precincts[precno];
- for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
- tcd_cblk_t *cblk=&prc->cblks[cblkno];
+ c = src;
+ d = c;
+ if (tcp->csty & J2K_CP_CSTY_SOP)
+ {
+ if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
+ c += 6;
+ }
+ bio_init_dec(c, src + len - c);
+ } else
+ {
+ if (tcp->ppt == 1)
+ {
+ tcp->ppt_data = c; /* Update pointer */
+ /* INDEX */
+ layer_Idx->len_header = c-d;
+
+ c = src;
+ d = c;
+ if (tcp->csty & J2K_CP_CSTY_SOP) /* SOP marker */
+ {
+ if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
+ c += 6;
+ }
+ bio_init_dec(c, src + len - c);
+
+ }
+ }
+
+ for (bandno = 0; bandno < res->numbands; bandno++) {
+ tcd_band_t *band = &res->bands[bandno];
+ tcd_precinct_t *prc = &band->precincts[precno];
+ for (cblkno = 0; cblkno < prc->cw*prc->ch; cblkno++) {
+ tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_seg_t *seg;
if (!cblk->numnewpasses) continue;
if (!cblk->numsegs) {
- seg=&cblk->segs[cblk->numsegs++];
- cblk->len=0;
+ seg = &cblk->segs[cblk->numsegs++];
+ cblk->len = 0;
} else {
- seg=&cblk->segs[cblk->numsegs-1];
- if (seg->numpasses==seg->maxpasses) {
+ seg = &cblk->segs[cblk->numsegs-1];
+ if (seg->numpasses == seg->maxpasses) {
seg++;
cblk->numsegs++;
}
}
do {
- if (c+seg->newlen>src+len) return -999;
- memcpy(cblk->data+cblk->len, c, seg->newlen);
- if (seg->numpasses==0) {
- seg->data=cblk->data+cblk->len;
+ if (c + seg->newlen > src + len) return -999;
+ memcpy(cblk->data + cblk->len, c, seg->newlen);
+ if (seg->numpasses == 0) {
+ seg->data = cblk->data + cblk->len;
}
- c+=seg->newlen;
- cblk->len+=seg->newlen;
- seg->len+=seg->newlen;
- seg->numpasses+=seg->numnewpasses;
- cblk->numnewpasses-=seg->numnewpasses;
- if (cblk->numnewpasses>0) {
+ c += seg->newlen;
+ cblk->len += seg->newlen;
+ seg->len += seg->newlen;
+ seg->numpasses += seg->numnewpasses;
+ cblk->numnewpasses -= seg->numnewpasses;
+ if (cblk->numnewpasses > 0) {
seg++;
cblk->numsegs++;
}
- } while (cblk->numnewpasses>0);
+ } while (cblk->numnewpasses > 0);
}
}
- //<INDEX>
- e=c-d;
- layer_Idx->len=e;
- //</INDEX>
+ /* <INDEX> */
+ e = c-d;
+ layer_Idx->len = e;
+ /* </INDEX> */
return c-src;
}
+void t2_init_info_packets(info_image_t *img, j2k_cp_t *cp)
+{
+ int compno, tileno, resno, precno, layno;
+
+ for(compno = 0; compno < img->Comp; compno++)
+ {
+ for(tileno = 0; tileno < img->tw*img->th; tileno++)
+ {
+ info_tile_t *tile_Idx = &img->tile[tileno];
+ info_compo_t *compo_Idx = &tile_Idx->compo[compno];
+ for(resno = 0; resno < img->Decomposition + 1 ; resno++)
+ {
+ info_reso_t *reso_Idx = &compo_Idx->reso[resno];
+ for (precno = 0; precno < img->tile[tileno].pw * img->tile[tileno].ph; precno++)
+ {
+ info_prec_t *prec_Idx = &reso_Idx->prec[precno];
+ for(layno = 0; layno < img->Layer ; layno++)
+ {
+ info_layer_t *layer_Idx = &prec_Idx->layer[layno];
+ layer_Idx->offset = 0; /* start position */
+ layer_Idx->len_header = 0; /* length */
+ }
+ }
+ }
+ }
+ }
+}
+
int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg) {
- unsigned char *c=src;
+ unsigned char *c = src;
pi_iterator_t *pi;
int pino, compno,e;
- int position=imgg->tile[tileno].end_header+1;
+ int partno;
+ info_tile_part_t *tile_part;
+ int position;
+ int length_read;
info_tile_t *tile_Idx;
info_compo_t *compo_Idx;
info_reso_t *reso_Idx;
info_prec_t *prec_Idx;
info_layer_t *layer_Idx;
- tile_Idx=&imgg->tile[tileno];
- tile_Idx->num_packet=0;
- pi=pi_create(img, cp, tileno);
+ t2_init_info_packets(imgg, cp); /* Initialize the packets information : LEN and OFFSET to 0 */
- for (pino=0; pino<=cp->tcps[tileno].numpocs;pino++)
- {
-
- while (pi_next(&pi[pino])) {
- compo_Idx=&tile_Idx->compo[pi[pino].compno];
- reso_Idx=&compo_Idx->reso[pi[pino].resno];
- prec_Idx=&reso_Idx->prec[pi[pino].precno];
- layer_Idx=&prec_Idx->layer[pi[pino].layno];
+ tile_Idx = &imgg->tile[tileno];
+ tile_Idx->num_packet = 0;
+ pi = pi_create(img, cp, tileno);
+ partno = 0;
+ tile_part = &tile_Idx->tile_parts[partno];
+ position = tile_part->end_header + 1;
+ length_read = 0;
- layer_Idx->offset=position;
-
- e=t2_decode_packet(c, src+len-c, tile, &cp->tcps[tileno], pi[pino].compno, pi[pino].resno, pi[pino].precno, pi[pino].layno,layer_Idx);
-
- if (e==-999)
- {
- break;
- } else
- c+=e;
- position+=e;
- tile_Idx->num_packet++;
- }
+ for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++)
+ {
+ while (pi_next(&pi[pino]))
+ {
+ compo_Idx = &tile_Idx->compo[pi[pino].compno];
+ reso_Idx = &compo_Idx->reso[pi[pino].resno];
+ prec_Idx = &reso_Idx->prec[pi[pino].precno];
+ layer_Idx = &prec_Idx->layer[pi[pino].layno];
+
+ layer_Idx->offset = position;
+ layer_Idx->offset_header = position;
+
+ e = t2_decode_packet(c, src+len-c, tile, cp, &cp->tcps[tileno], pi[pino].compno, pi[pino].resno, pi[pino].precno, pi[pino].layno,layer_Idx);
+ if (e == -999)
+ {
+ break;
+ } else
+ c += e;
+ position += e;
+
+ /* Update position in case of multiple tile-parts for a tile >> */
+ length_read += e;
+ if (length_read >= (tile_part->end_pos - tile_part->end_header))
+ {
+ partno++;
+ tile_part = &tile_Idx->tile_parts[partno];
+ position = tile_part->end_header + 1;
+ length_read = 0;
+ }
+ /* << end_update */
+
+ tile_Idx->num_packet++;
+ }
// FREE space memory taken by pi
- for (compno=0; compno<pi[pino].numcomps; compno++)
+ for (compno = 0; compno < pi[pino].numcomps; compno++)
{
free(pi[pino].comps[compno].resolutions);
}
free(pi[pino].comps);
}
- free(pi);
+ free(pi[0].include);
+ free(pi);
+
if (e==-999)
return e;
else
static j2k_image_t *tcd_img;
static j2k_cp_t *tcd_cp;
-static tcd_tile_t *tcd_tile;
-static j2k_tcp_t *tcd_tcp;
-static int tcd_tileno;
-
extern jmp_buf j2k_error;
void tcd_init(j2k_image_t *img, j2k_cp_t *cp, info_image_t *imgg) {
int tcd_decode_tile(unsigned char *src, int len, int tileno, info_image_t *imgg) {
int l;
int eof=0;
-
tcd_tile_t *tile;
- tcd_tileno=tileno;
- tcd_tile=&tcd_image.tiles[tileno];
- tcd_tcp=&tcd_cp->tcps[tileno];
- tile=tcd_tile;
- l=t2_decode_packets(src, len, tcd_img, tcd_cp, tileno, tile, imgg);
+ tile = &tcd_image.tiles[tileno];
+
+ l = t2_decode_packets(src, len, tcd_img, tcd_cp, tileno, tile, imgg);
if (l==-999)
{
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
- * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
projects / openjpeg / commitdiff