(no commit message)

diff --git a/ChangeLog b/ChangeLog
index b46a1249ceac2c394ec2fd190c23f1c84053f35f..9f3f4670463a89f2cc42b4a684939c7f7456cc76 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -5,6 +5,11 @@ What's New for OpenJPEG
 ! : changed
 + : added
 
+July 13, 2007
+! [FOD] Modified the memory allocation for codestreams containing multiple tiles. The memory is now allocated for each tile indenpendently, leading to an important decrease of the virtual memory needed. [j2k.c tcd.h tcd.c]
+! [FOD] Modified old comments about the ability to decode mega-images and comments about the disk size necessary to do this. [image_to_j2k.c and frames_to_mj2.c]
+* [FOD] Added 2000 bytes for the memory allocation in cio.c for the minimum size of headers (useful in case of very small images) [cio.c]
+
 July 12, 2007
 * [GB] fixed a bug in JPWL module, which prevented to exploit the full error correction capability of RS codes (e.g. it gave up at 5 errors, even if 6 were correctable); defined a JPWL_MAXIMUM_EPB_ROOM for better customization of the maximum dimension of EPBs (the dimension is pre-calculated on an hypothesis, if it goes beyond 65535 there will be problems, thus we give a little less than the max, let's say 65450)
 

diff --git a/codec/image_to_j2k.c b/codec/image_to_j2k.c
index 113f2f1d6ec03548b9a4833550d3bd3bf5c398c3..73708e30a164b43a45081c6bf9ef03cb57271474 100644 (file)
--- a/codec/image_to_j2k.c
+++ b/codec/image_to_j2k.c
@@ -98,10 +98,6 @@ void encode_help_display() {
        fprintf(stdout,"The markers written to the main_header are : SOC SIZ COD QCD COM.\n");
        fprintf(stdout,"COD and QCD never appear in the tile_header.\n");
        fprintf(stdout,"\n");
-       fprintf(stdout,"- This coder can encode a mega image, a test was made on a 24000x24000 pixels \n");
-       fprintf(stdout,"color image.  You need enough disk space memory (twice the original) to encode \n");
-       fprintf(stdout,"the image,i.e. for a 1.5 GB image you need a minimum of 3GB of disk memory)\n");
-       fprintf(stdout,"\n");
        fprintf(stdout,"By default:\n");
        fprintf(stdout,"------------\n");
        fprintf(stdout,"\n");

diff --git a/libopenjpeg/cio.c b/libopenjpeg/cio.c
index cb0c3e4a3a14de2f2a09ee5cb4eb67797a561378..a462edb2d5642d93d35b5f422378dd3140171401 100644 (file)
--- a/libopenjpeg/cio.c
+++ b/libopenjpeg/cio.c
@@ -58,7 +58,7 @@ opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer
                                opj_free(cio);
                                return NULL;
                }
-               cio->length = (int) (0.1625 * cp->img_size); /* 0.1625 = 1.3/8 */
+               cio->length = (int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
                cio->buffer = (unsigned char *)opj_malloc(cio->length);
                if(!cio->buffer) {
                        opj_free(cio);

diff --git a/libopenjpeg/j2k.c b/libopenjpeg/j2k.c
index 556833c63e611172de12b45074f5ca4716c7a5b9..9cb99e869b95780d0c75d46e9d1e1efb23f2f5a7 100644 (file)
--- a/libopenjpeg/j2k.c
+++ b/libopenjpeg/j2k.c
@@ -1484,10 +1484,12 @@ static void j2k_read_eoc(opj_j2k_t *j2k) {
                opj_tcd_t *tcd = tcd_create(j2k->cinfo);
                tcd_malloc_decode(tcd, j2k->image, j2k->cp);
                for (i = 0; i < j2k->cp->tileno_size; i++) {
+                       tcd_malloc_decode_tile(tcd, j2k->image, j2k->cp, i);
                        tileno = j2k->cp->tileno[i];
                        tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno);
                        opj_free(j2k->tile_data[tileno]);
                        j2k->tile_data[tileno] = NULL;
+                       tcd_free_decode_tile(tcd, i);
                }
                tcd_free_decode(tcd);
                tcd_destroy(tcd);

diff --git a/libopenjpeg/tcd.c b/libopenjpeg/tcd.c
index 525ec91d53efb4df44ba596e36d08d3be6cedd31..2253c5b40ab32c564f7c19b49551d84633728ad1 100644 (file)
--- a/libopenjpeg/tcd.c
+++ b/libopenjpeg/tcd.c
@@ -573,206 +573,233 @@ void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int cur
 }
 
 void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp) {
-       int tileno, compno, resno, bandno, precno, cblkno, i, j, p, q;
+       int i, j, tileno, p, q;
        unsigned int x0 = 0, y0 = 0, x1 = 0, y1 = 0, w, h;
 
        tcd->image = image;
-       tcd->cp = cp;
        tcd->tcd_image->tw = cp->tw;
        tcd->tcd_image->th = cp->th;
        tcd->tcd_image->tiles = (opj_tcd_tile_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcd_tile_t));
-       
-       for (i = 0; i < cp->tileno_size; i++) {
-               opj_tcp_t *tcp = &(cp->tcps[cp->tileno[i]]);
-               opj_tcd_tile_t *tile = &(tcd->tcd_image->tiles[cp->tileno[i]]);
-       
-               /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */
-               tileno = cp->tileno[i];
-               p = tileno % cp->tw;    /* si numerotation matricielle .. */
-               q = tileno / cp->tw;    /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */
 
-               /* 4 borders of the tile rescale on the image if necessary */
-               tile->x0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
-               tile->y0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
-               tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
-               tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+       /* 
+       Allocate place to store the decoded data = final image
+       Place limited by the tile really present in the codestream 
+       */
+
+       for (j = 0; j < cp->tileno_size; j++) {
+               opj_tcd_tile_t *tile;
+               
+               tileno = cp->tileno[j];
+               
+               tile = &(tcd->tcd_image->tiles[cp->tileno[tileno]]);
                
                tile->numcomps = image->numcomps;
                tile->comps = (opj_tcd_tilecomp_t *) opj_malloc(image->numcomps * sizeof(opj_tcd_tilecomp_t));
-               for (compno = 0; compno < tile->numcomps; compno++) {
-                       opj_tccp_t *tccp = &tcp->tccps[compno];
-                       opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+       }
 
-                       /* border of each tile component (global) */
-                       tilec->x0 = int_ceildiv(tile->x0, image->comps[compno].dx);
-                       tilec->y0 = int_ceildiv(tile->y0, image->comps[compno].dy);
-                       tilec->x1 = int_ceildiv(tile->x1, image->comps[compno].dx);
-                       tilec->y1 = int_ceildiv(tile->y1, image->comps[compno].dy);
+       
+       for (i = 0; i < image->numcomps; i++) {
+               for (j = 0; j < cp->tileno_size; j++) {
+                       opj_tcd_tile_t *tile;
+                       opj_tcd_tilecomp_t *tilec;
                        
-                       tilec->data = (int *) opj_malloc((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0) * sizeof(int));
-                       tilec->numresolutions = tccp->numresolutions;
-                       tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(tilec->numresolutions * sizeof(opj_tcd_resolution_t));
+                       /* cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */
+                       
+                       tileno = cp->tileno[j];
+                       
+                       tile = &(tcd->tcd_image->tiles[cp->tileno[tileno]]);
+                       tilec = &tile->comps[i];
+                       
+                       p = tileno % cp->tw;    /* si numerotation matricielle .. */
+                       q = tileno / cp->tw;    /* .. coordonnees de la tile (q,p) q pour ligne et p pour colonne */
+                       
+                       /* 4 borders of the tile rescale on the image if necessary */
+                       tile->x0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
+                       tile->y0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
+                       tile->x1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
+                       tile->y1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
+
+                       tilec->x0 = int_ceildiv(tile->x0, image->comps[i].dx);
+                       tilec->y0 = int_ceildiv(tile->y0, image->comps[i].dy);
+                       tilec->x1 = int_ceildiv(tile->x1, image->comps[i].dx);
+                       tilec->y1 = int_ceildiv(tile->y1, image->comps[i].dy);
+
+                       x0 = j == 0 ? tilec->x0 : int_min(x0, (unsigned int) tilec->x0);
+                       y0 = j == 0 ? tilec->y0 : int_min(y0,   (unsigned int) tilec->x0);
+                       x1 = j == 0 ? tilec->x1 : int_max(x1,   (unsigned int) tilec->x1);
+                       y1 = j == 0 ? tilec->y1 : int_max(y1,   (unsigned int) tilec->y1);
+               }
+               
+               w = x1 - x0;
+               h = y1 - y0;
+               
+               image->comps[i].data = (int *) opj_malloc(w * h * sizeof(int));
+               image->comps[i].w = w;
+               image->comps[i].h = h;
+               image->comps[i].x0 = x0;
+               image->comps[i].y0 = y0;
+       }
 
-                       for (resno = 0; resno < tilec->numresolutions; resno++) {
-                               int pdx, pdy;
-                               int levelno = tilec->numresolutions - 1 - resno;
-                               int tlprcxstart, tlprcystart, brprcxend, brprcyend;
-                               int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
-                               int cbgwidthexpn, cbgheightexpn;
-                               int cblkwidthexpn, cblkheightexpn;
+}
 
-                               opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int tileno) {
+       int compno, resno, bandno, precno, cblkno;
+       unsigned int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+       opj_tcp_t *tcp;
+       opj_tcd_tile_t *tile;
+
+       tcd->cp = cp;
+       
+       tcp = &(cp->tcps[cp->tileno[tileno]]);
+       tile = &(tcd->tcd_image->tiles[cp->tileno[tileno]]);
+       
+       tileno = cp->tileno[tileno];
+       
+       for (compno = 0; compno < tile->numcomps; compno++) {
+               opj_tccp_t *tccp = &tcp->tccps[compno];
+               opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+               
+               /* border of each tile component (global) */
+               tilec->x0 = int_ceildiv(tile->x0, image->comps[compno].dx);
+               tilec->y0 = int_ceildiv(tile->y0, image->comps[compno].dy);
+               tilec->x1 = int_ceildiv(tile->x1, image->comps[compno].dx);
+               tilec->y1 = int_ceildiv(tile->y1, image->comps[compno].dy);
+               
+               tilec->data = (int *) opj_malloc((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0) * sizeof(int));
+               tilec->numresolutions = tccp->numresolutions;
+               tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(tilec->numresolutions * sizeof(opj_tcd_resolution_t));
+               
+               for (resno = 0; resno < tilec->numresolutions; resno++) {
+                       int pdx, pdy;
+                       int levelno = tilec->numresolutions - 1 - resno;
+                       int tlprcxstart, tlprcystart, brprcxend, brprcyend;
+                       int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
+                       int cbgwidthexpn, cbgheightexpn;
+                       int cblkwidthexpn, cblkheightexpn;
+                       
+                       opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                       
+                       /* border for each resolution level (global) */
+                       res->x0 = int_ceildivpow2(tilec->x0, levelno);
+                       res->y0 = int_ceildivpow2(tilec->y0, levelno);
+                       res->x1 = int_ceildivpow2(tilec->x1, levelno);
+                       res->y1 = int_ceildivpow2(tilec->y1, levelno);
+                       res->numbands = resno == 0 ? 1 : 3;
+                       
+                       /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
+                       if (tccp->csty & J2K_CCP_CSTY_PRT) {
+                               pdx = tccp->prcw[resno];
+                               pdy = tccp->prch[resno];
+                       } else {
+                               pdx = 15;
+                               pdy = 15;
+                       }
+                       
+                       /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)  */
+                       tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;
+                       tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;
+                       brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;
+                       brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;
+                       
+                       res->pw = (res->x0 == res->x1) ? 0 : ((brprcxend - tlprcxstart) >> pdx);
+                       res->ph = (res->y0 == res->y1) ? 0 : ((brprcyend - tlprcystart) >> pdy);
+                       
+                       if (resno == 0) {
+                               tlcbgxstart = tlprcxstart;
+                               tlcbgystart = tlprcystart;
+                               brcbgxend = brprcxend;
+                               brcbgyend = brprcyend;
+                               cbgwidthexpn = pdx;
+                               cbgheightexpn = pdy;
+                       } else {
+                               tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);
+                               tlcbgystart = int_ceildivpow2(tlprcystart, 1);
+                               brcbgxend = int_ceildivpow2(brprcxend, 1);
+                               brcbgyend = int_ceildivpow2(brprcyend, 1);
+                               cbgwidthexpn = pdx - 1;
+                               cbgheightexpn = pdy - 1;
+                       }
+                       
+                       cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);
+                       cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);
+                       
+                       for (bandno = 0; bandno < res->numbands; bandno++) {
+                               int x0b, y0b;
+                               int gain, numbps;
+                               opj_stepsize_t *ss = NULL;
                                
-                               /* border for each resolution level (global) */
-                               res->x0 = int_ceildivpow2(tilec->x0, levelno);
-                               res->y0 = int_ceildivpow2(tilec->y0, levelno);
-                               res->x1 = int_ceildivpow2(tilec->x1, levelno);
-                               res->y1 = int_ceildivpow2(tilec->y1, levelno);
-                               res->numbands = resno == 0 ? 1 : 3;
+                               opj_tcd_band_t *band = &res->bands[bandno];
+                               band->bandno = resno == 0 ? 0 : bandno + 1;
+                               x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;
+                               y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;
                                
-                               /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */
-                               if (tccp->csty & J2K_CCP_CSTY_PRT) {
-                                       pdx = tccp->prcw[resno];
-                                       pdy = tccp->prch[resno];
+                               if (band->bandno == 0) {
+                                       /* band border (global) */
+                                       band->x0 = int_ceildivpow2(tilec->x0, levelno);
+                                       band->y0 = int_ceildivpow2(tilec->y0, levelno);
+                                       band->x1 = int_ceildivpow2(tilec->x1, levelno);
+                                       band->y1 = int_ceildivpow2(tilec->y1, levelno);
                                } else {
-                                       pdx = 15;
-                                       pdy = 15;
+                                       /* band border (global) */
+                                       band->x0 = int_ceildivpow2(tilec->x0 - (1 << levelno) * x0b, levelno + 1);
+                                       band->y0 = int_ceildivpow2(tilec->y0 - (1 << levelno) * y0b, levelno + 1);
+                                       band->x1 = int_ceildivpow2(tilec->x1 - (1 << levelno) * x0b, levelno + 1);
+                                       band->y1 = int_ceildivpow2(tilec->y1 - (1 << levelno) * y0b, levelno + 1);
                                }
                                
-                               /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)  */
-                               tlprcxstart = int_floordivpow2(res->x0, pdx) << pdx;
-                               tlprcystart = int_floordivpow2(res->y0, pdy) << pdy;
-                               brprcxend = int_ceildivpow2(res->x1, pdx) << pdx;
-                               brprcyend = int_ceildivpow2(res->y1, pdy) << pdy;
-
-                               res->pw = (res->x0 == res->x1) ? 0 : ((brprcxend - tlprcxstart) >> pdx);
-                               res->ph = (res->y0 == res->y1) ? 0 : ((brprcyend - tlprcystart) >> pdy);
-                               
-                               if (resno == 0) {
-                                       tlcbgxstart = tlprcxstart;
-                                       tlcbgystart = tlprcystart;
-                                       brcbgxend = brprcxend;
-                                       brcbgyend = brprcyend;
-                                       cbgwidthexpn = pdx;
-                                       cbgheightexpn = pdy;
-                               } else {
-                                       tlcbgxstart = int_ceildivpow2(tlprcxstart, 1);
-                                       tlcbgystart = int_ceildivpow2(tlprcystart, 1);
-                                       brcbgxend = int_ceildivpow2(brprcxend, 1);
-                                       brcbgyend = int_ceildivpow2(brprcyend, 1);
-                                       cbgwidthexpn = pdx - 1;
-                                       cbgheightexpn = pdy - 1;
-                               }
+                               ss = &tccp->stepsizes[resno == 0 ? 0 : 3 * (resno - 1) + bandno + 1];
+                               gain = tccp->qmfbid == 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);
+                               numbps = image->comps[compno].prec + gain;
+                               band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));
+                               band->numbps = ss->expn + tccp->numgbits - 1;   /* WHY -1 ? */
                                
-                               cblkwidthexpn = int_min(tccp->cblkw, cbgwidthexpn);
-                               cblkheightexpn = int_min(tccp->cblkh, cbgheightexpn);
+                               band->precincts = (opj_tcd_precinct_t *) opj_malloc(res->pw * res->ph * sizeof(opj_tcd_precinct_t));
                                
-                               for (bandno = 0; bandno < res->numbands; bandno++) {
-                                       int x0b, y0b;
-                                       int gain, numbps;
-                                       opj_stepsize_t *ss = NULL;
-
-                                       opj_tcd_band_t *band = &res->bands[bandno];
-                                       band->bandno = resno == 0 ? 0 : bandno + 1;
-                                       x0b = (band->bandno == 1) || (band->bandno == 3) ? 1 : 0;
-                                       y0b = (band->bandno == 2) || (band->bandno == 3) ? 1 : 0;
+                               for (precno = 0; precno < res->pw * res->ph; precno++) {
+                                       int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
+                                       int cbgxstart = tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);
+                                       int cbgystart = tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);
+                                       int cbgxend = cbgxstart + (1 << cbgwidthexpn);
+                                       int cbgyend = cbgystart + (1 << cbgheightexpn);
                                        
-                                       if (band->bandno == 0) {
-                                               /* band border (global) */
-                                               band->x0 = int_ceildivpow2(tilec->x0, levelno);
-                                               band->y0 = int_ceildivpow2(tilec->y0, levelno);
-                                               band->x1 = int_ceildivpow2(tilec->x1, levelno);
-                                               band->y1 = int_ceildivpow2(tilec->y1, levelno);
-                                       } else {
-                                               /* band border (global) */
-                                               band->x0 = int_ceildivpow2(tilec->x0 - (1 << levelno) * x0b, levelno + 1);
-                                               band->y0 = int_ceildivpow2(tilec->y0 - (1 << levelno) * y0b, levelno + 1);
-                                               band->x1 = int_ceildivpow2(tilec->x1 - (1 << levelno) * x0b, levelno + 1);
-                                               band->y1 = int_ceildivpow2(tilec->y1 - (1 << levelno) * y0b, levelno + 1);
-                                       }
+                                       opj_tcd_precinct_t *prc = &band->precincts[precno];
+                                       /* precinct size (global) */
+                                       prc->x0 = int_max(cbgxstart, band->x0);
+                                       prc->y0 = int_max(cbgystart, band->y0);
+                                       prc->x1 = int_min(cbgxend, band->x1);
+                                       prc->y1 = int_min(cbgyend, band->y1);
                                        
-                                       ss = &tccp->stepsizes[resno == 0 ? 0 : 3 * (resno - 1) + bandno + 1];
-                                       gain = tccp->qmfbid == 0 ? dwt_getgain_real(band->bandno) : dwt_getgain(band->bandno);
-                                       numbps = image->comps[compno].prec + gain;
-                                       band->stepsize = (float)((1.0 + ss->mant / 2048.0) * pow(2.0, numbps - ss->expn));
-                                       band->numbps = ss->expn + tccp->numgbits - 1;   /* WHY -1 ? */
+                                       tlcblkxstart = int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;
+                                       tlcblkystart = int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;
+                                       brcblkxend = int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;
+                                       brcblkyend = int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;
+                                       prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;
+                                       prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;
                                        
-                                       band->precincts = (opj_tcd_precinct_t *) opj_malloc(res->pw * res->ph * sizeof(opj_tcd_precinct_t));
+                                       prc->cblks = (opj_tcd_cblk_t *) opj_malloc(prc->cw * prc->ch * sizeof(opj_tcd_cblk_t));
                                        
-                                       for (precno = 0; precno < res->pw * res->ph; precno++) {
-                                               int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
-                                               int cbgxstart = tlcbgxstart + (precno % res->pw) * (1 << cbgwidthexpn);
-                                               int cbgystart = tlcbgystart + (precno / res->pw) * (1 << cbgheightexpn);
-                                               int cbgxend = cbgxstart + (1 << cbgwidthexpn);
-                                               int cbgyend = cbgystart + (1 << cbgheightexpn);
-
-                                               opj_tcd_precinct_t *prc = &band->precincts[precno];
-                                               /* precinct size (global) */
-                                               prc->x0 = int_max(cbgxstart, band->x0);
-                                               prc->y0 = int_max(cbgystart, band->y0);
-                                               prc->x1 = int_min(cbgxend, band->x1);
-                                               prc->y1 = int_min(cbgyend, band->y1);
-                                               
-                                               tlcblkxstart = int_floordivpow2(prc->x0, cblkwidthexpn) << cblkwidthexpn;
-                                               tlcblkystart = int_floordivpow2(prc->y0, cblkheightexpn) << cblkheightexpn;
-                                               brcblkxend = int_ceildivpow2(prc->x1, cblkwidthexpn) << cblkwidthexpn;
-                                               brcblkyend = int_ceildivpow2(prc->y1, cblkheightexpn) << cblkheightexpn;
-                                               prc->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;
-                                               prc->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;
-                                               
-                                               prc->cblks = (opj_tcd_cblk_t *) opj_malloc(prc->cw * prc->ch * sizeof(opj_tcd_cblk_t));
-                                               
-                                               prc->incltree = tgt_create(prc->cw, prc->ch);
-                                               prc->imsbtree = tgt_create(prc->cw, prc->ch);
+                                       prc->incltree = tgt_create(prc->cw, prc->ch);
+                                       prc->imsbtree = tgt_create(prc->cw, prc->ch);
+                                       
+                                       for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+                                               int cblkxstart = tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);
+                                               int cblkystart = tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);
+                                               int cblkxend = cblkxstart + (1 << cblkwidthexpn);
+                                               int cblkyend = cblkystart + (1 << cblkheightexpn);                                      
                                                
-                                               for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-                                                       int cblkxstart = tlcblkxstart + (cblkno % prc->cw) * (1 << cblkwidthexpn);
-                                                       int cblkystart = tlcblkystart + (cblkno / prc->cw) * (1 << cblkheightexpn);
-                                                       int cblkxend = cblkxstart + (1 << cblkwidthexpn);
-                                                       int cblkyend = cblkystart + (1 << cblkheightexpn);                                      
-                                                       
-                                                       /* code-block size (global) */
-                                                       opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
-                                                       cblk->x0 = int_max(cblkxstart, prc->x0);
-                                                       cblk->y0 = int_max(cblkystart, prc->y0);
-                                                       cblk->x1 = int_min(cblkxend, prc->x1);
-                                                       cblk->y1 = int_min(cblkyend, prc->y1);
-                                               }
-                                       } /* precno */
-                               } /* bandno */
-                       } /* resno */
-               } /* compno */
-       } /* i = 0..cp->tileno_size */
-
-       /* tcd_dump(stdout, tcd, &tcd->tcd_image); */
-
-       /* 
-       Allocate place to store the decoded data = final image
-       Place limited by the tile really present in the codestream 
-       */
+                                               /* code-block size (global) */
+                                               opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+                                               cblk->x0 = int_max(cblkxstart, prc->x0);
+                                               cblk->y0 = int_max(cblkystart, prc->y0);
+                                               cblk->x1 = int_min(cblkxend, prc->x1);
+                                               cblk->y1 = int_min(cblkyend, prc->y1);
+                                       }
+                               } /* precno */
+                       } /* bandno */
+               } /* resno */
+       } /* compno */
        
-       for (i = 0; i < image->numcomps; i++) {
-               for (j = 0; j < cp->tileno_size; j++) {
-                       tileno = cp->tileno[j];
-                       x0 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].x0 : int_min(x0,
-                               (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].x0);
-                       y0 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].y0 : int_min(y0,
-                               (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].y0);
-                       x1 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].x1 : int_max(x1,
-                               (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].x1);
-                       y1 = j == 0 ? tcd->tcd_image->tiles[tileno].comps[i].y1 : int_max(y1, 
-                               (unsigned int) tcd->tcd_image->tiles[tileno].comps[i].y1);
-               }
-               
-               w = x1 - x0;
-               h = y1 - y0;
-               
-               image->comps[i].data = (int *) opj_malloc(w * h * sizeof(int));
-               image->comps[i].w = w;
-               image->comps[i].h = h;
-               image->comps[i].x0 = x0;
-               image->comps[i].y0 = y0;
-       }
+       /* tcd_dump(stdout, tcd, &tcd->tcd_image); */
 }
 
 void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final) {
@@ -1378,32 +1405,34 @@ bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno) {
 }
 
 void tcd_free_decode(opj_tcd_t *tcd) {
-       int tileno,compno,resno,bandno,precno;
+       opj_tcd_image_t *tcd_image = tcd->tcd_image;    
+       if (tcd_image->tiles != NULL) opj_free(tcd_image->tiles);
+}
+
+void tcd_free_decode_tile(opj_tcd_t *tcd, int tileno) {
+       int compno,resno,bandno,precno;
 
        opj_tcd_image_t *tcd_image = tcd->tcd_image;
-       
-       for (tileno = 0; tileno < tcd_image->tw * tcd_image->th; tileno++) {
-               opj_tcd_tile_t *tile = &tcd_image->tiles[tileno];
-               for (compno = 0; compno < tile->numcomps; compno++) {
-                       opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
-                       for (resno = 0; resno < tilec->numresolutions; resno++) {
-                               opj_tcd_resolution_t *res = &tilec->resolutions[resno];
-                               for (bandno = 0; bandno < res->numbands; bandno++) {
-                                       opj_tcd_band_t *band = &res->bands[bandno];
-                                       for (precno = 0; precno < res->ph * res->pw; precno++) {
-                                               opj_tcd_precinct_t *prec = &band->precincts[precno];
-                                               if (prec->cblks != NULL) opj_free(prec->cblks);
-                                               if (prec->imsbtree != NULL) tgt_destroy(prec->imsbtree);
-                                               if (prec->incltree != NULL) tgt_destroy(prec->incltree);
-                                       }
-                                       if (band->precincts != NULL) opj_free(band->precincts);
+
+       opj_tcd_tile_t *tile = &tcd_image->tiles[tileno];
+       for (compno = 0; compno < tile->numcomps; compno++) {
+               opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+               for (resno = 0; resno < tilec->numresolutions; resno++) {
+                       opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+                       for (bandno = 0; bandno < res->numbands; bandno++) {
+                               opj_tcd_band_t *band = &res->bands[bandno];
+                               for (precno = 0; precno < res->ph * res->pw; precno++) {
+                                       opj_tcd_precinct_t *prec = &band->precincts[precno];
+                                       if (prec->cblks != NULL) opj_free(prec->cblks);
+                                       if (prec->imsbtree != NULL) tgt_destroy(prec->imsbtree);
+                                       if (prec->incltree != NULL) tgt_destroy(prec->incltree);
                                }
+                               if (band->precincts != NULL) opj_free(band->precincts);
                        }
-                       if (tilec->resolutions != NULL) opj_free(tilec->resolutions);
                }
-               if (tile->comps != NULL) opj_free(tile->comps);
+               if (tilec->resolutions != NULL) opj_free(tilec->resolutions);
        }
-
-       if (tcd_image->tiles != NULL) opj_free(tcd_image->tiles);
+       if (tile->comps != NULL) opj_free(tile->comps);
 }
 
+

diff --git a/libopenjpeg/tcd.h b/libopenjpeg/tcd.h
index ae667098c99a523905432b7a756abaccc8c96232..836926d67220acbd21f1743c6d55882dcd9672b1 100644 (file)
--- a/libopenjpeg/tcd.h
+++ b/libopenjpeg/tcd.h
@@ -234,6 +234,7 @@ Initialize the tile decoder
 @param cp Coding parameters
 */
 void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp);
+void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int tileno);
 void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
 void tcd_rateallocate_fixed(opj_tcd_t *tcd);
 void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
@@ -261,6 +262,7 @@ Free the memory allocated for decoding
 @param tcd TCD handle
 */
 void tcd_free_decode(opj_tcd_t *tcd);
+void tcd_free_decode_tile(opj_tcd_t *tcd, int tileno);
 
 /* ----------------------------------------------------------------------- */
 /*@}*/

diff --git a/mj2/frames_to_mj2.c b/mj2/frames_to_mj2.c
index 0ab8fc12074eda43936bec2319a8a65dcb3bca79..d95fbeb7b20289ad466d87679630d7bd291cf92b 100644 (file)
--- a/mj2/frames_to_mj2.c
+++ b/mj2/frames_to_mj2.c
@@ -78,13 +78,6 @@ void help_display()
   fprintf
     (stdout,"COD and QCD never appear in the tile_header.\n");
   fprintf(stdout,"\n");
-  fprintf
-    (stdout,"- This coder can encode a mega image, a test was made on a 24000x24000 pixels \n");
-  fprintf
-    (stdout,"color image.  You need enough disk space memory (twice the original) to encode \n");
-  fprintf
-    (stdout,"the image,i.e. for a 1.5 GB image you need a minimum of 3GB of disk memory)\n");
-  fprintf(stdout,"\n");
   fprintf(stdout,"By default:\n");
   fprintf(stdout,"------------\n");
   fprintf(stdout,"\n");