1/* 2 * The copyright in this software is being made available under the 2-clauses 3 * BSD License, included below. This software may be subject to other third 4 * party and contributor rights, including patent rights, and no such rights 5 * are granted under this license. 6 * 7 * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium 8 * Copyright (c) 2002-2014, Professor Benoit Macq 9 * Copyright (c) 2001-2003, David Janssens 10 * Copyright (c) 2002-2003, Yannick Verschueren 11 * Copyright (c) 2003-2007, Francois-Olivier Devaux 12 * Copyright (c) 2003-2014, Antonin Descampe 13 * Copyright (c) 2005, Herve Drolon, FreeImage Team 14 * Copyright (c) 2006-2007, Parvatha Elangovan 15 * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR 16 * Copyright (c) 2012, CS Systemes d'Information, France 17 * All rights reserved. 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions and the following disclaimer. 24 * 2. Redistributions in binary form must reproduce the above copyright 25 * notice, this list of conditions and the following disclaimer in the 26 * documentation and/or other materials provided with the distribution. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' 29 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 32 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 33 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 34 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 37 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 * POSSIBILITY OF SUCH DAMAGE. 39 */ 40 41#include "opj_includes.h" 42 43/* ----------------------------------------------------------------------- */ 44 45/* TODO MSD: */ 46#ifdef TODO_MSD 47void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t * img) { 48 int tileno, compno, resno, bandno, precno;/*, cblkno;*/ 49 50 fprintf(fd, "image {\n"); 51 fprintf(fd, " tw=%d, th=%d x0=%d x1=%d y0=%d y1=%d\n", 52 img->tw, img->th, tcd->image->x0, tcd->image->x1, tcd->image->y0, tcd->image->y1); 53 54 for (tileno = 0; tileno < img->th * img->tw; tileno++) { 55 opj_tcd_tile_t *tile = &tcd->tcd_image->tiles[tileno]; 56 fprintf(fd, " tile {\n"); 57 fprintf(fd, " x0=%d, y0=%d, x1=%d, y1=%d, numcomps=%d\n", 58 tile->x0, tile->y0, tile->x1, tile->y1, tile->numcomps); 59 for (compno = 0; compno < tile->numcomps; compno++) { 60 opj_tcd_tilecomp_t *tilec = &tile->comps[compno]; 61 fprintf(fd, " tilec {\n"); 62 fprintf(fd, 63 " x0=%d, y0=%d, x1=%d, y1=%d, numresolutions=%d\n", 64 tilec->x0, tilec->y0, tilec->x1, tilec->y1, tilec->numresolutions); 65 for (resno = 0; resno < tilec->numresolutions; resno++) { 66 opj_tcd_resolution_t *res = &tilec->resolutions[resno]; 67 fprintf(fd, "\n res {\n"); 68 fprintf(fd, 69 " x0=%d, y0=%d, x1=%d, y1=%d, pw=%d, ph=%d, numbands=%d\n", 70 res->x0, res->y0, res->x1, res->y1, res->pw, res->ph, res->numbands); 71 for (bandno = 0; bandno < res->numbands; bandno++) { 72 opj_tcd_band_t *band = &res->bands[bandno]; 73 fprintf(fd, " band {\n"); 74 fprintf(fd, 75 " x0=%d, y0=%d, x1=%d, y1=%d, stepsize=%f, numbps=%d\n", 76 band->x0, band->y0, band->x1, band->y1, band->stepsize, band->numbps); 77 for (precno = 0; precno < res->pw * res->ph; precno++) { 78 opj_tcd_precinct_t *prec = &band->precincts[precno]; 79 fprintf(fd, " prec {\n"); 80 fprintf(fd, 81 " x0=%d, y0=%d, x1=%d, y1=%d, cw=%d, ch=%d\n", 82 prec->x0, prec->y0, prec->x1, prec->y1, prec->cw, prec->ch); 83 /* 84 for (cblkno = 0; cblkno < prec->cw * prec->ch; cblkno++) { 85 opj_tcd_cblk_t *cblk = &prec->cblks[cblkno]; 86 fprintf(fd, " cblk {\n"); 87 fprintf(fd, 88 " x0=%d, y0=%d, x1=%d, y1=%d\n", 89 cblk->x0, cblk->y0, cblk->x1, cblk->y1); 90 fprintf(fd, " }\n"); 91 } 92 */ 93 fprintf(fd, " }\n"); 94 } 95 fprintf(fd, " }\n"); 96 } 97 fprintf(fd, " }\n"); 98 } 99 fprintf(fd, " }\n"); 100 } 101 fprintf(fd, " }\n"); 102 } 103 fprintf(fd, "}\n"); 104} 105#endif 106 107/** 108 * Initializes tile coding/decoding 109 */ 110static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block, opj_event_mgr_t* manager); 111 112/** 113* Allocates memory for a decoding code block. 114*/ 115static OPJ_BOOL opj_tcd_code_block_dec_allocate (opj_tcd_cblk_dec_t * p_code_block); 116 117/** 118 * Deallocates the decoding data of the given precinct. 119 */ 120static void opj_tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct); 121 122/** 123 * Allocates memory for an encoding code block (but not data). 124 */ 125static OPJ_BOOL opj_tcd_code_block_enc_allocate (opj_tcd_cblk_enc_t * p_code_block); 126 127/** 128 * Allocates data for an encoding code block 129 */ 130static OPJ_BOOL opj_tcd_code_block_enc_allocate_data (opj_tcd_cblk_enc_t * p_code_block); 131 132/** 133 * Deallocates the encoding data of the given precinct. 134 */ 135static void opj_tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct); 136 137 138/** 139Free the memory allocated for encoding 140@param tcd TCD handle 141*/ 142static void opj_tcd_free_tile(opj_tcd_t *tcd); 143 144 145static OPJ_BOOL opj_tcd_t2_decode ( opj_tcd_t *p_tcd, 146 OPJ_BYTE * p_src_data, 147 OPJ_UINT32 * p_data_read, 148 OPJ_UINT32 p_max_src_size, 149 opj_codestream_index_t *p_cstr_index, 150 opj_event_mgr_t *p_manager); 151 152static OPJ_BOOL opj_tcd_t1_decode (opj_tcd_t *p_tcd); 153 154static OPJ_BOOL opj_tcd_dwt_decode (opj_tcd_t *p_tcd); 155 156static OPJ_BOOL opj_tcd_mct_decode (opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager); 157 158static OPJ_BOOL opj_tcd_dc_level_shift_decode (opj_tcd_t *p_tcd); 159 160 161static OPJ_BOOL opj_tcd_dc_level_shift_encode ( opj_tcd_t *p_tcd ); 162 163static OPJ_BOOL opj_tcd_mct_encode ( opj_tcd_t *p_tcd ); 164 165static OPJ_BOOL opj_tcd_dwt_encode ( opj_tcd_t *p_tcd ); 166 167static OPJ_BOOL opj_tcd_t1_encode ( opj_tcd_t *p_tcd ); 168 169static OPJ_BOOL opj_tcd_t2_encode ( opj_tcd_t *p_tcd, 170 OPJ_BYTE * p_dest_data, 171 OPJ_UINT32 * p_data_written, 172 OPJ_UINT32 p_max_dest_size, 173 opj_codestream_info_t *p_cstr_info ); 174 175static OPJ_BOOL opj_tcd_rate_allocate_encode( opj_tcd_t *p_tcd, 176 OPJ_BYTE * p_dest_data, 177 OPJ_UINT32 p_max_dest_size, 178 opj_codestream_info_t *p_cstr_info ); 179 180/* ----------------------------------------------------------------------- */ 181 182/** 183Create a new TCD handle 184*/ 185opj_tcd_t* opj_tcd_create(OPJ_BOOL p_is_decoder) 186{ 187 opj_tcd_t *l_tcd = 00; 188 189 /* create the tcd structure */ 190 l_tcd = (opj_tcd_t*) opj_calloc(1,sizeof(opj_tcd_t)); 191 if (!l_tcd) { 192 return 00; 193 } 194 195 l_tcd->m_is_decoder = p_is_decoder ? 1 : 0; 196 197 l_tcd->tcd_image = (opj_tcd_image_t*)opj_calloc(1,sizeof(opj_tcd_image_t)); 198 if (!l_tcd->tcd_image) { 199 opj_free(l_tcd); 200 return 00; 201 } 202 203 return l_tcd; 204} 205 206 207/* ----------------------------------------------------------------------- */ 208 209void opj_tcd_rateallocate_fixed(opj_tcd_t *tcd) { 210 OPJ_UINT32 layno; 211 212 for (layno = 0; layno < tcd->tcp->numlayers; layno++) { 213 opj_tcd_makelayer_fixed(tcd, layno, 1); 214 } 215} 216 217 218void opj_tcd_makelayer( opj_tcd_t *tcd, 219 OPJ_UINT32 layno, 220 OPJ_FLOAT64 thresh, 221 OPJ_UINT32 final) 222{ 223 OPJ_UINT32 compno, resno, bandno, precno, cblkno; 224 OPJ_UINT32 passno; 225 226 opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles; 227 228 tcd_tile->distolayer[layno] = 0; /* fixed_quality */ 229 230 for (compno = 0; compno < tcd_tile->numcomps; compno++) { 231 opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno]; 232 233 for (resno = 0; resno < tilec->numresolutions; resno++) { 234 opj_tcd_resolution_t *res = &tilec->resolutions[resno]; 235 236 for (bandno = 0; bandno < res->numbands; bandno++) { 237 opj_tcd_band_t *band = &res->bands[bandno]; 238 239 for (precno = 0; precno < res->pw * res->ph; precno++) { 240 opj_tcd_precinct_t *prc = &band->precincts[precno]; 241 242 for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { 243 opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno]; 244 opj_tcd_layer_t *layer = &cblk->layers[layno]; 245 OPJ_UINT32 n; 246 247 if (layno == 0) { 248 cblk->numpassesinlayers = 0; 249 } 250 251 n = cblk->numpassesinlayers; 252 253 for (passno = cblk->numpassesinlayers; passno < cblk->totalpasses; passno++) { 254 OPJ_UINT32 dr; 255 OPJ_FLOAT64 dd; 256 opj_tcd_pass_t *pass = &cblk->passes[passno]; 257 258 if (n == 0) { 259 dr = pass->rate; 260 dd = pass->distortiondec; 261 } else { 262 dr = pass->rate - cblk->passes[n - 1].rate; 263 dd = pass->distortiondec - cblk->passes[n - 1].distortiondec; 264 } 265 266 if (!dr) { 267 if (dd != 0) 268 n = passno + 1; 269 continue; 270 } 271 if (thresh - (dd / dr) < DBL_EPSILON) /* do not rely on float equality, check with DBL_EPSILON margin */ 272 n = passno + 1; 273 } 274 275 layer->numpasses = n - cblk->numpassesinlayers; 276 277 if (!layer->numpasses) { 278 layer->disto = 0; 279 continue; 280 } 281 282 if (cblk->numpassesinlayers == 0) { 283 layer->len = cblk->passes[n - 1].rate; 284 layer->data = cblk->data; 285 layer->disto = cblk->passes[n - 1].distortiondec; 286 } else { 287 layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate; 288 layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate; 289 layer->disto = cblk->passes[n - 1].distortiondec - cblk->passes[cblk->numpassesinlayers - 1].distortiondec; 290 } 291 292 tcd_tile->distolayer[layno] += layer->disto; /* fixed_quality */ 293 294 if (final) 295 cblk->numpassesinlayers = n; 296 } 297 } 298 } 299 } 300 } 301} 302 303void opj_tcd_makelayer_fixed(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_UINT32 final) { 304 OPJ_UINT32 compno, resno, bandno, precno, cblkno; 305 OPJ_INT32 value; /*, matrice[tcd_tcp->numlayers][tcd_tile->comps[0].numresolutions][3]; */ 306 OPJ_INT32 matrice[10][10][3]; 307 OPJ_UINT32 i, j, k; 308 309 opj_cp_t *cp = tcd->cp; 310 opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles; 311 opj_tcp_t *tcd_tcp = tcd->tcp; 312 313 for (compno = 0; compno < tcd_tile->numcomps; compno++) { 314 opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno]; 315 316 for (i = 0; i < tcd_tcp->numlayers; i++) { 317 for (j = 0; j < tilec->numresolutions; j++) { 318 for (k = 0; k < 3; k++) { 319 matrice[i][j][k] = 320 (OPJ_INT32) ((OPJ_FLOAT32)cp->m_specific_param.m_enc.m_matrice[i * tilec->numresolutions * 3 + j * 3 + k] 321 * (OPJ_FLOAT32) (tcd->image->comps[compno].prec / 16.0)); 322 } 323 } 324 } 325 326 for (resno = 0; resno < tilec->numresolutions; resno++) { 327 opj_tcd_resolution_t *res = &tilec->resolutions[resno]; 328 329 for (bandno = 0; bandno < res->numbands; bandno++) { 330 opj_tcd_band_t *band = &res->bands[bandno]; 331 332 for (precno = 0; precno < res->pw * res->ph; precno++) { 333 opj_tcd_precinct_t *prc = &band->precincts[precno]; 334 335 for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { 336 opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno]; 337 opj_tcd_layer_t *layer = &cblk->layers[layno]; 338 OPJ_UINT32 n; 339 OPJ_INT32 imsb = (OPJ_INT32)(tcd->image->comps[compno].prec - cblk->numbps); /* number of bit-plan equal to zero */ 340 341 /* Correction of the matrix of coefficient to include the IMSB information */ 342 if (layno == 0) { 343 value = matrice[layno][resno][bandno]; 344 if (imsb >= value) { 345 value = 0; 346 } else { 347 value -= imsb; 348 } 349 } else { 350 value = matrice[layno][resno][bandno] - matrice[layno - 1][resno][bandno]; 351 if (imsb >= matrice[layno - 1][resno][bandno]) { 352 value -= (imsb - matrice[layno - 1][resno][bandno]); 353 if (value < 0) { 354 value = 0; 355 } 356 } 357 } 358 359 if (layno == 0) { 360 cblk->numpassesinlayers = 0; 361 } 362 363 n = cblk->numpassesinlayers; 364 if (cblk->numpassesinlayers == 0) { 365 if (value != 0) { 366 n = 3 * (OPJ_UINT32)value - 2 + cblk->numpassesinlayers; 367 } else { 368 n = cblk->numpassesinlayers; 369 } 370 } else { 371 n = 3 * (OPJ_UINT32)value + cblk->numpassesinlayers; 372 } 373 374 layer->numpasses = n - cblk->numpassesinlayers; 375 376 if (!layer->numpasses) 377 continue; 378 379 if (cblk->numpassesinlayers == 0) { 380 layer->len = cblk->passes[n - 1].rate; 381 layer->data = cblk->data; 382 } else { 383 layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate; 384 layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate; 385 } 386 387 if (final) 388 cblk->numpassesinlayers = n; 389 } 390 } 391 } 392 } 393 } 394} 395 396OPJ_BOOL opj_tcd_rateallocate( opj_tcd_t *tcd, 397 OPJ_BYTE *dest, 398 OPJ_UINT32 * p_data_written, 399 OPJ_UINT32 len, 400 opj_codestream_info_t *cstr_info) 401{ 402 OPJ_UINT32 compno, resno, bandno, precno, cblkno, layno; 403 OPJ_UINT32 passno; 404 OPJ_FLOAT64 min, max; 405 OPJ_FLOAT64 cumdisto[100]; /* fixed_quality */ 406 const OPJ_FLOAT64 K = 1; /* 1.1; fixed_quality */ 407 OPJ_FLOAT64 maxSE = 0; 408 409 opj_cp_t *cp = tcd->cp; 410 opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles; 411 opj_tcp_t *tcd_tcp = tcd->tcp; 412 413 min = DBL_MAX; 414 max = 0; 415 416 tcd_tile->numpix = 0; /* fixed_quality */ 417 418 for (compno = 0; compno < tcd_tile->numcomps; compno++) { 419 opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno]; 420 tilec->numpix = 0; 421 422 for (resno = 0; resno < tilec->numresolutions; resno++) { 423 opj_tcd_resolution_t *res = &tilec->resolutions[resno]; 424 425 for (bandno = 0; bandno < res->numbands; bandno++) { 426 opj_tcd_band_t *band = &res->bands[bandno]; 427 428 for (precno = 0; precno < res->pw * res->ph; precno++) { 429 opj_tcd_precinct_t *prc = &band->precincts[precno]; 430 431 for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { 432 opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno]; 433 434 for (passno = 0; passno < cblk->totalpasses; passno++) { 435 opj_tcd_pass_t *pass = &cblk->passes[passno]; 436 OPJ_INT32 dr; 437 OPJ_FLOAT64 dd, rdslope; 438 439 if (passno == 0) { 440 dr = (OPJ_INT32)pass->rate; 441 dd = pass->distortiondec; 442 } else { 443 dr = (OPJ_INT32)(pass->rate - cblk->passes[passno - 1].rate); 444 dd = pass->distortiondec - cblk->passes[passno - 1].distortiondec; 445 } 446 447 if (dr == 0) { 448 continue; 449 } 450 451 rdslope = dd / dr; 452 if (rdslope < min) { 453 min = rdslope; 454 } 455 456 if (rdslope > max) { 457 max = rdslope; 458 } 459 } /* passno */ 460 461 /* fixed_quality */ 462 tcd_tile->numpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0)); 463 tilec->numpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0)); 464 } /* cbklno */ 465 } /* precno */ 466 } /* bandno */ 467 } /* resno */ 468 469 maxSE += (((OPJ_FLOAT64)(1 << tcd->image->comps[compno].prec) - 1.0) 470 * ((OPJ_FLOAT64)(1 << tcd->image->comps[compno].prec) -1.0)) 471 * ((OPJ_FLOAT64)(tilec->numpix)); 472 } /* compno */ 473 474 /* index file */ 475 if(cstr_info) { 476 opj_tile_info_t *tile_info = &cstr_info->tile[tcd->tcd_tileno]; 477 tile_info->numpix = tcd_tile->numpix; 478 tile_info->distotile = tcd_tile->distotile; 479 tile_info->thresh = (OPJ_FLOAT64 *) opj_malloc(tcd_tcp->numlayers * sizeof(OPJ_FLOAT64)); 480 if (!tile_info->thresh) { 481 /* FIXME event manager error callback */ 482 return OPJ_FALSE; 483 } 484 } 485 486 for (layno = 0; layno < tcd_tcp->numlayers; layno++) { 487 OPJ_FLOAT64 lo = min; 488 OPJ_FLOAT64 hi = max; 489 OPJ_BOOL success = OPJ_FALSE; 490 OPJ_UINT32 maxlen = tcd_tcp->rates[layno] ? opj_uint_min(((OPJ_UINT32) ceil(tcd_tcp->rates[layno])), len) : len; 491 OPJ_FLOAT64 goodthresh = 0; 492 OPJ_FLOAT64 stable_thresh = 0; 493 OPJ_UINT32 i; 494 OPJ_FLOAT64 distotarget; /* fixed_quality */ 495 496 /* fixed_quality */ 497 distotarget = tcd_tile->distotile - ((K * maxSE) / pow((OPJ_FLOAT32)10, tcd_tcp->distoratio[layno] / 10)); 498 499 /* Don't try to find an optimal threshold but rather take everything not included yet, if 500 -r xx,yy,zz,0 (disto_alloc == 1 and rates == 0) 501 -q xx,yy,zz,0 (fixed_quality == 1 and distoratio == 0) 502 ==> possible to have some lossy layers and the last layer for sure lossless */ 503 if ( ((cp->m_specific_param.m_enc.m_disto_alloc==1) && (tcd_tcp->rates[layno]>0)) || ((cp->m_specific_param.m_enc.m_fixed_quality==1) && (tcd_tcp->distoratio[layno]>0))) { 504 opj_t2_t*t2 = opj_t2_create(tcd->image, cp); 505 OPJ_FLOAT64 thresh = 0; 506 507 if (t2 == 00) { 508 return OPJ_FALSE; 509 } 510 511 for (i = 0; i < 128; ++i) { 512 OPJ_FLOAT64 distoachieved = 0; /* fixed_quality */ 513 514 thresh = (lo + hi) / 2; 515 516 opj_tcd_makelayer(tcd, layno, thresh, 0); 517 518 if (cp->m_specific_param.m_enc.m_fixed_quality) { /* fixed_quality */ 519 if(OPJ_IS_CINEMA(cp->rsiz)){ 520 if (! opj_t2_encode_packets(t2,tcd->tcd_tileno, tcd_tile, layno + 1, dest, p_data_written, maxlen, cstr_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC)) { 521 522 lo = thresh; 523 continue; 524 } 525 else { 526 distoachieved = layno == 0 ? 527 tcd_tile->distolayer[0] : cumdisto[layno - 1] + tcd_tile->distolayer[layno]; 528 529 if (distoachieved < distotarget) { 530 hi=thresh; 531 stable_thresh = thresh; 532 continue; 533 }else{ 534 lo=thresh; 535 } 536 } 537 }else{ 538 distoachieved = (layno == 0) ? 539 tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]); 540 541 if (distoachieved < distotarget) { 542 hi = thresh; 543 stable_thresh = thresh; 544 continue; 545 } 546 lo = thresh; 547 } 548 } else { 549 if (! opj_t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest,p_data_written, maxlen, cstr_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC)) 550 { 551 /* TODO: what to do with l ??? seek / tell ??? */ 552 /* opj_event_msg(tcd->cinfo, EVT_INFO, "rate alloc: len=%d, max=%d\n", l, maxlen); */ 553 lo = thresh; 554 continue; 555 } 556 557 hi = thresh; 558 stable_thresh = thresh; 559 } 560 } 561 562 success = OPJ_TRUE; 563 goodthresh = stable_thresh == 0? thresh : stable_thresh; 564 565 opj_t2_destroy(t2); 566 } else { 567 success = OPJ_TRUE; 568 goodthresh = min; 569 } 570 571 if (!success) { 572 return OPJ_FALSE; 573 } 574 575 if(cstr_info) { /* Threshold for Marcela Index */ 576 cstr_info->tile[tcd->tcd_tileno].thresh[layno] = goodthresh; 577 } 578 579 opj_tcd_makelayer(tcd, layno, goodthresh, 1); 580 581 /* fixed_quality */ 582 cumdisto[layno] = (layno == 0) ? tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]); 583 } 584 585 return OPJ_TRUE; 586} 587 588OPJ_BOOL opj_tcd_init( opj_tcd_t *p_tcd, 589 opj_image_t * p_image, 590 opj_cp_t * p_cp ) 591{ 592 p_tcd->image = p_image; 593 p_tcd->cp = p_cp; 594 595 p_tcd->tcd_image->tiles = (opj_tcd_tile_t *) opj_calloc(1,sizeof(opj_tcd_tile_t)); 596 if (! p_tcd->tcd_image->tiles) { 597 return OPJ_FALSE; 598 } 599 600 p_tcd->tcd_image->tiles->comps = (opj_tcd_tilecomp_t *) opj_calloc(p_image->numcomps,sizeof(opj_tcd_tilecomp_t)); 601 if (! p_tcd->tcd_image->tiles->comps ) { 602 return OPJ_FALSE; 603 } 604 605 p_tcd->tcd_image->tiles->numcomps = p_image->numcomps; 606 p_tcd->tp_pos = p_cp->m_specific_param.m_enc.m_tp_pos; 607 608 return OPJ_TRUE; 609} 610 611/** 612Destroy a previously created TCD handle 613*/ 614void opj_tcd_destroy(opj_tcd_t *tcd) { 615 if (tcd) { 616 opj_tcd_free_tile(tcd); 617 618 if (tcd->tcd_image) { 619 opj_free(tcd->tcd_image); 620 tcd->tcd_image = 00; 621 } 622 opj_free(tcd); 623 } 624} 625 626OPJ_BOOL opj_alloc_tile_component_data(opj_tcd_tilecomp_t *l_tilec) 627{ 628 if ((l_tilec->data == 00) || ((l_tilec->data_size_needed > l_tilec->data_size) && (l_tilec->ownsData == OPJ_FALSE))) { 629 l_tilec->data = (OPJ_INT32 *) opj_malloc(l_tilec->data_size_needed); 630 if (! l_tilec->data ) { 631 return OPJ_FALSE; 632 } 633 /*fprintf(stderr, "tAllocate data of tilec (int): %d x OPJ_UINT32n",l_data_size);*/ 634 l_tilec->data_size = l_tilec->data_size_needed; 635 l_tilec->ownsData = OPJ_TRUE; 636 } 637 else if (l_tilec->data_size_needed > l_tilec->data_size) { 638 OPJ_INT32 * new_data = (OPJ_INT32 *) opj_realloc(l_tilec->data, l_tilec->data_size_needed); 639 /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle tile datan"); */ 640 /* fprintf(stderr, "Not enough memory to handle tile data"); */ 641 if (! new_data) { 642 opj_free(l_tilec->data); 643 l_tilec->data = NULL; 644 l_tilec->data_size = 0; 645 l_tilec->data_size_needed = 0; 646 l_tilec->ownsData = OPJ_FALSE; 647 return OPJ_FALSE; 648 } 649 l_tilec->data = new_data; 650 /*fprintf(stderr, "tReallocate data of tilec (int): from %d to %d x OPJ_UINT32n", l_tilec->data_size, l_data_size);*/ 651 l_tilec->data_size = l_tilec->data_size_needed; 652 l_tilec->ownsData = OPJ_TRUE; 653 } 654 return OPJ_TRUE; 655} 656 657/* ----------------------------------------------------------------------- */ 658 659static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BOOL isEncoder, OPJ_FLOAT32 fraction, OPJ_SIZE_T sizeof_block, opj_event_mgr_t* manager) 660{ 661 OPJ_UINT32 (*l_gain_ptr)(OPJ_UINT32) = 00; 662 OPJ_UINT32 compno, resno, bandno, precno, cblkno; 663 opj_tcp_t * l_tcp = 00; 664 opj_cp_t * l_cp = 00; 665 opj_tcd_tile_t * l_tile = 00; 666 opj_tccp_t *l_tccp = 00; 667 opj_tcd_tilecomp_t *l_tilec = 00; 668 opj_image_comp_t * l_image_comp = 00; 669 opj_tcd_resolution_t *l_res = 00; 670 opj_tcd_band_t *l_band = 00; 671 opj_stepsize_t * l_step_size = 00; 672 opj_tcd_precinct_t *l_current_precinct = 00; 673 opj_image_t *l_image = 00; 674 OPJ_UINT32 p,q; 675 OPJ_UINT32 l_level_no; 676 OPJ_UINT32 l_pdx, l_pdy; 677 OPJ_UINT32 l_gain; 678 OPJ_INT32 l_x0b, l_y0b; 679 OPJ_UINT32 l_tx0, l_ty0; 680 /* extent of precincts , top left, bottom right**/ 681 OPJ_INT32 l_tl_prc_x_start, l_tl_prc_y_start, l_br_prc_x_end, l_br_prc_y_end; 682 /* number of precinct for a resolution */ 683 OPJ_UINT32 l_nb_precincts; 684 /* room needed to store l_nb_precinct precinct for a resolution */ 685 OPJ_UINT32 l_nb_precinct_size; 686 /* number of code blocks for a precinct*/ 687 OPJ_UINT32 l_nb_code_blocks; 688 /* room needed to store l_nb_code_blocks code blocks for a precinct*/ 689 OPJ_UINT32 l_nb_code_blocks_size; 690 /* size of data for a tile */ 691 OPJ_UINT32 l_data_size; 692 693 l_cp = p_tcd->cp; 694 l_tcp = &(l_cp->tcps[p_tile_no]); 695 l_tile = p_tcd->tcd_image->tiles; 696 l_tccp = l_tcp->tccps; 697 l_tilec = l_tile->comps; 698 l_image = p_tcd->image; 699 l_image_comp = p_tcd->image->comps; 700 701 p = p_tile_no % l_cp->tw; /* tile coordinates */ 702 q = p_tile_no / l_cp->tw; 703 /*fprintf(stderr, "Tile coordinate = %d,%d\n", p, q);*/ 704 705 /* 4 borders of the tile rescale on the image if necessary */ 706 l_tx0 = l_cp->tx0 + p * l_cp->tdx; /* can't be greater than l_image->x1 so won't overflow */ 707 l_tile->x0 = (OPJ_INT32)opj_uint_max(l_tx0, l_image->x0); 708 l_tile->x1 = (OPJ_INT32)opj_uint_min(opj_uint_adds(l_tx0, l_cp->tdx), l_image->x1); 709 l_ty0 = l_cp->ty0 + q * l_cp->tdy; /* can't be greater than l_image->y1 so won't overflow */ 710 l_tile->y0 = (OPJ_INT32)opj_uint_max(l_ty0, l_image->y0); 711 l_tile->y1 = (OPJ_INT32)opj_uint_min(opj_uint_adds(l_ty0, l_cp->tdy), l_image->y1); 712 713 /* testcase 1888.pdf.asan.35.988 */ 714 if (l_tccp->numresolutions == 0) { 715 opj_event_msg(manager, EVT_ERROR, "tiles require at least one resolution\n"); 716 return OPJ_FALSE; 717 } 718 /*fprintf(stderr, "Tile border = %d,%d,%d,%d\n", l_tile->x0, l_tile->y0,l_tile->x1,l_tile->y1);*/ 719 720 /*tile->numcomps = image->numcomps; */ 721 for (compno = 0; compno < l_tile->numcomps; ++compno) { 722 /*fprintf(stderr, "compno = %d/%d\n", compno, l_tile->numcomps);*/ 723 l_image_comp->resno_decoded = 0; 724 /* border of each l_tile component (global) */ 725 l_tilec->x0 = opj_int_ceildiv(l_tile->x0, (OPJ_INT32)l_image_comp->dx); 726 l_tilec->y0 = opj_int_ceildiv(l_tile->y0, (OPJ_INT32)l_image_comp->dy); 727 l_tilec->x1 = opj_int_ceildiv(l_tile->x1, (OPJ_INT32)l_image_comp->dx); 728 l_tilec->y1 = opj_int_ceildiv(l_tile->y1, (OPJ_INT32)l_image_comp->dy); 729 /*fprintf(stderr, "\tTile compo border = %d,%d,%d,%d\n", l_tilec->x0, l_tilec->y0,l_tilec->x1,l_tilec->y1);*/ 730 if (l_tilec->x0 >= l_tilec->x1 || l_tilec->y0 >= l_tilec->y1) { 731 opj_event_msg(manager, EVT_ERROR, "Invalid tile data\n"); 732 return OPJ_FALSE; 733 } 734 /* compute l_data_size with overflow check */ 735 l_data_size = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0); 736 if ((((OPJ_UINT32)-1) / l_data_size) < (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0)) { 737 opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n"); 738 return OPJ_FALSE; 739 } 740 l_data_size = l_data_size * (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0); 741 742 if ((((OPJ_UINT32)-1) / (OPJ_UINT32)sizeof(OPJ_UINT32)) < l_data_size) { 743 opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n"); 744 return OPJ_FALSE; 745 } 746 l_data_size = l_data_size * (OPJ_UINT32)sizeof(OPJ_UINT32); 747 l_tilec->numresolutions = l_tccp->numresolutions; 748 if (l_tccp->numresolutions < l_cp->m_specific_param.m_dec.m_reduce) { 749 l_tilec->minimum_num_resolutions = 1; 750 } 751 else { 752 l_tilec->minimum_num_resolutions = l_tccp->numresolutions - l_cp->m_specific_param.m_dec.m_reduce; 753 } 754 755 l_tilec->data_size_needed = l_data_size; 756 if (p_tcd->m_is_decoder && !opj_alloc_tile_component_data(l_tilec)) { 757 opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n"); 758 return OPJ_FALSE; 759 } 760 761 l_data_size = l_tilec->numresolutions * (OPJ_UINT32)sizeof(opj_tcd_resolution_t); 762 763 if (l_tilec->resolutions == 00) { 764 l_tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(l_data_size); 765 if (! l_tilec->resolutions ) { 766 return OPJ_FALSE; 767 } 768 /*fprintf(stderr, "\tAllocate resolutions of tilec (opj_tcd_resolution_t): %d\n",l_data_size);*/ 769 l_tilec->resolutions_size = l_data_size; 770 memset(l_tilec->resolutions,0,l_data_size); 771 } 772 else if (l_data_size > l_tilec->resolutions_size) { 773 opj_tcd_resolution_t* new_resolutions = (opj_tcd_resolution_t *) opj_realloc(l_tilec->resolutions, l_data_size); 774 if (! new_resolutions) { 775 opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile resolutions\n"); 776 opj_free(l_tilec->resolutions); 777 l_tilec->resolutions = NULL; 778 l_tilec->resolutions_size = 0; 779 return OPJ_FALSE; 780 } 781 l_tilec->resolutions = new_resolutions; 782 /*fprintf(stderr, "\tReallocate data of tilec (int): from %d to %d x OPJ_UINT32\n", l_tilec->resolutions_size, l_data_size);*/ 783 memset(((OPJ_BYTE*) l_tilec->resolutions)+l_tilec->resolutions_size,0,l_data_size - l_tilec->resolutions_size); 784 l_tilec->resolutions_size = l_data_size; 785 } 786 787 l_level_no = l_tilec->numresolutions - 1; 788 l_res = l_tilec->resolutions; 789 l_step_size = l_tccp->stepsizes; 790 if (l_tccp->qmfbid == 0) { 791 l_gain_ptr = &opj_dwt_getgain_real; 792 } 793 else { 794 l_gain_ptr = &opj_dwt_getgain; 795 } 796 /*fprintf(stderr, "\tlevel_no=%d\n",l_level_no);*/ 797 798 for (resno = 0; resno < l_tilec->numresolutions; ++resno) { 799 /*fprintf(stderr, "\t\tresno = %d/%d\n", resno, l_tilec->numresolutions);*/ 800 OPJ_INT32 tlcbgxstart, tlcbgystart /*, brcbgxend, brcbgyend*/; 801 OPJ_UINT32 cbgwidthexpn, cbgheightexpn; 802 OPJ_UINT32 cblkwidthexpn, cblkheightexpn; 803 804 /* border for each resolution level (global) */ 805 l_res->x0 = opj_int_ceildivpow2(l_tilec->x0, (OPJ_INT32)l_level_no); 806 l_res->y0 = opj_int_ceildivpow2(l_tilec->y0, (OPJ_INT32)l_level_no); 807 l_res->x1 = opj_int_ceildivpow2(l_tilec->x1, (OPJ_INT32)l_level_no); 808 l_res->y1 = opj_int_ceildivpow2(l_tilec->y1, (OPJ_INT32)l_level_no); 809 /*fprintf(stderr, "\t\t\tres_x0= %d, res_y0 =%d, res_x1=%d, res_y1=%d\n", l_res->x0, l_res->y0, l_res->x1, l_res->y1);*/ 810 /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */ 811 l_pdx = l_tccp->prcw[resno]; 812 l_pdy = l_tccp->prch[resno]; 813 /*fprintf(stderr, "\t\t\tpdx=%d, pdy=%d\n", l_pdx, l_pdy);*/ 814 /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */ 815 l_tl_prc_x_start = opj_int_floordivpow2(l_res->x0, (OPJ_INT32)l_pdx) << l_pdx; 816 l_tl_prc_y_start = opj_int_floordivpow2(l_res->y0, (OPJ_INT32)l_pdy) << l_pdy; 817 l_br_prc_x_end = opj_int_ceildivpow2(l_res->x1, (OPJ_INT32)l_pdx) << l_pdx; 818 l_br_prc_y_end = opj_int_ceildivpow2(l_res->y1, (OPJ_INT32)l_pdy) << l_pdy; 819 /*fprintf(stderr, "\t\t\tprc_x_start=%d, prc_y_start=%d, br_prc_x_end=%d, br_prc_y_end=%d \n", l_tl_prc_x_start, l_tl_prc_y_start, l_br_prc_x_end ,l_br_prc_y_end );*/ 820 821 l_res->pw = (l_res->x0 == l_res->x1) ? 0 : (OPJ_UINT32)((l_br_prc_x_end - l_tl_prc_x_start) >> l_pdx); 822 l_res->ph = (l_res->y0 == l_res->y1) ? 0 : (OPJ_UINT32)((l_br_prc_y_end - l_tl_prc_y_start) >> l_pdy); 823 /*fprintf(stderr, "\t\t\tres_pw=%d, res_ph=%d\n", l_res->pw, l_res->ph );*/ 824 825 l_nb_precincts = l_res->pw * l_res->ph; 826 l_nb_precinct_size = l_nb_precincts * (OPJ_UINT32)sizeof(opj_tcd_precinct_t); 827 if (resno == 0) { 828 tlcbgxstart = l_tl_prc_x_start; 829 tlcbgystart = l_tl_prc_y_start; 830 /*brcbgxend = l_br_prc_x_end;*/ 831 /* brcbgyend = l_br_prc_y_end;*/ 832 cbgwidthexpn = l_pdx; 833 cbgheightexpn = l_pdy; 834 l_res->numbands = 1; 835 } 836 else { 837 tlcbgxstart = opj_int_ceildivpow2(l_tl_prc_x_start, 1); 838 tlcbgystart = opj_int_ceildivpow2(l_tl_prc_y_start, 1); 839 /*brcbgxend = opj_int_ceildivpow2(l_br_prc_x_end, 1);*/ 840 /*brcbgyend = opj_int_ceildivpow2(l_br_prc_y_end, 1);*/ 841 cbgwidthexpn = l_pdx - 1; 842 cbgheightexpn = l_pdy - 1; 843 l_res->numbands = 3; 844 } 845 846 cblkwidthexpn = opj_uint_min(l_tccp->cblkw, cbgwidthexpn); 847 cblkheightexpn = opj_uint_min(l_tccp->cblkh, cbgheightexpn); 848 l_band = l_res->bands; 849 850 for (bandno = 0; bandno < l_res->numbands; ++bandno) { 851 OPJ_INT32 numbps; 852 /*fprintf(stderr, "\t\t\tband_no=%d/%d\n", bandno, l_res->numbands );*/ 853 854 if (resno == 0) { 855 l_band->bandno = 0 ; 856 l_band->x0 = opj_int_ceildivpow2(l_tilec->x0, (OPJ_INT32)l_level_no); 857 l_band->y0 = opj_int_ceildivpow2(l_tilec->y0, (OPJ_INT32)l_level_no); 858 l_band->x1 = opj_int_ceildivpow2(l_tilec->x1, (OPJ_INT32)l_level_no); 859 l_band->y1 = opj_int_ceildivpow2(l_tilec->y1, (OPJ_INT32)l_level_no); 860 } 861 else { 862 l_band->bandno = bandno + 1; 863 /* x0b = 1 if bandno = 1 or 3 */ 864 l_x0b = l_band->bandno&1; 865 /* y0b = 1 if bandno = 2 or 3 */ 866 l_y0b = (OPJ_INT32)((l_band->bandno)>>1); 867 /* l_band border (global) */ 868 l_band->x0 = opj_int64_ceildivpow2(l_tilec->x0 - ((OPJ_INT64)l_x0b << l_level_no), (OPJ_INT32)(l_level_no + 1)); 869 l_band->y0 = opj_int64_ceildivpow2(l_tilec->y0 - ((OPJ_INT64)l_y0b << l_level_no), (OPJ_INT32)(l_level_no + 1)); 870 l_band->x1 = opj_int64_ceildivpow2(l_tilec->x1 - ((OPJ_INT64)l_x0b << l_level_no), (OPJ_INT32)(l_level_no + 1)); 871 l_band->y1 = opj_int64_ceildivpow2(l_tilec->y1 - ((OPJ_INT64)l_y0b << l_level_no), (OPJ_INT32)(l_level_no + 1)); 872 } 873 874 /** avoid an if with storing function pointer */ 875 l_gain = (*l_gain_ptr) (l_band->bandno); 876 numbps = (OPJ_INT32)(l_image_comp->prec + l_gain); 877 l_band->stepsize = (OPJ_FLOAT32)(((1.0 + l_step_size->mant / 2048.0) * pow(2.0, (OPJ_INT32) (numbps - l_step_size->expn)))) * fraction; 878 l_band->numbps = l_step_size->expn + (OPJ_INT32)l_tccp->numgbits - 1; /* WHY -1 ? */ 879 880 if (! l_band->precincts) { 881 l_band->precincts = (opj_tcd_precinct_t *) opj_malloc( /*3 * */ l_nb_precinct_size); 882 if (! l_band->precincts) { 883 return OPJ_FALSE; 884 } 885 /*fprintf(stderr, "\t\t\t\tAllocate precincts of a band (opj_tcd_precinct_t): %d\n",l_nb_precinct_size); */ 886 memset(l_band->precincts,0,l_nb_precinct_size); 887 l_band->precincts_data_size = l_nb_precinct_size; 888 } 889 else if (l_band->precincts_data_size < l_nb_precinct_size) { 890 891 opj_tcd_precinct_t * new_precincts = (opj_tcd_precinct_t *) opj_realloc(l_band->precincts,/*3 * */ l_nb_precinct_size); 892 if (! new_precincts) { 893 opj_event_msg(manager, EVT_ERROR, "Not enough memory to handle band precints\n"); 894 opj_free(l_band->precincts); 895 l_band->precincts = NULL; 896 l_band->precincts_data_size = 0; 897 return OPJ_FALSE; 898 } 899 l_band->precincts = new_precincts; 900 /*fprintf(stderr, "\t\t\t\tReallocate precincts of a band (opj_tcd_precinct_t): from %d to %d\n",l_band->precincts_data_size, l_nb_precinct_size);*/ 901 memset(((OPJ_BYTE *) l_band->precincts) + l_band->precincts_data_size,0,l_nb_precinct_size - l_band->precincts_data_size); 902 l_band->precincts_data_size = l_nb_precinct_size; 903 } 904 905 l_current_precinct = l_band->precincts; 906 for (precno = 0; precno < l_nb_precincts; ++precno) { 907 OPJ_INT32 tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend; 908 OPJ_INT32 cbgxstart = tlcbgxstart + (OPJ_INT32)(precno % l_res->pw) * (1 << cbgwidthexpn); 909 OPJ_INT32 cbgystart = tlcbgystart + (OPJ_INT32)(precno / l_res->pw) * (1 << cbgheightexpn); 910 OPJ_INT32 cbgxend = cbgxstart + (1 << cbgwidthexpn); 911 OPJ_INT32 cbgyend = cbgystart + (1 << cbgheightexpn); 912 /*fprintf(stderr, "\t precno=%d; bandno=%d, resno=%d; compno=%d\n", precno, bandno , resno, compno);*/ 913 /*fprintf(stderr, "\t tlcbgxstart(=%d) + (precno(=%d) percent res->pw(=%d)) * (1 << cbgwidthexpn(=%d)) \n",tlcbgxstart,precno,l_res->pw,cbgwidthexpn);*/ 914 915 /* precinct size (global) */ 916 /*fprintf(stderr, "\t cbgxstart=%d, l_band->x0 = %d \n",cbgxstart, l_band->x0);*/ 917 918 l_current_precinct->x0 = opj_int_max(cbgxstart, l_band->x0); 919 l_current_precinct->y0 = opj_int_max(cbgystart, l_band->y0); 920 l_current_precinct->x1 = opj_int_min(cbgxend, l_band->x1); 921 l_current_precinct->y1 = opj_int_min(cbgyend, l_band->y1); 922 /*fprintf(stderr, "\t prc_x0=%d; prc_y0=%d, prc_x1=%d; prc_y1=%d\n",l_current_precinct->x0, l_current_precinct->y0 ,l_current_precinct->x1, l_current_precinct->y1);*/ 923 924 tlcblkxstart = opj_int_floordivpow2(l_current_precinct->x0, (OPJ_INT32)cblkwidthexpn) << cblkwidthexpn; 925 /*fprintf(stderr, "\t tlcblkxstart =%d\n",tlcblkxstart );*/ 926 tlcblkystart = opj_int_floordivpow2(l_current_precinct->y0, (OPJ_INT32)cblkheightexpn) << cblkheightexpn; 927 /*fprintf(stderr, "\t tlcblkystart =%d\n",tlcblkystart );*/ 928 brcblkxend = opj_int_ceildivpow2(l_current_precinct->x1, (OPJ_INT32)cblkwidthexpn) << cblkwidthexpn; 929 /*fprintf(stderr, "\t brcblkxend =%d\n",brcblkxend );*/ 930 brcblkyend = opj_int_ceildivpow2(l_current_precinct->y1, (OPJ_INT32)cblkheightexpn) << cblkheightexpn; 931 /*fprintf(stderr, "\t brcblkyend =%d\n",brcblkyend );*/ 932 l_current_precinct->cw = (OPJ_UINT32)((brcblkxend - tlcblkxstart) >> cblkwidthexpn); 933 l_current_precinct->ch = (OPJ_UINT32)((brcblkyend - tlcblkystart) >> cblkheightexpn); 934 935 l_nb_code_blocks = l_current_precinct->cw * l_current_precinct->ch; 936 /*fprintf(stderr, "\t\t\t\t precinct_cw = %d x recinct_ch = %d\n",l_current_precinct->cw, l_current_precinct->ch); */ 937 l_nb_code_blocks_size = l_nb_code_blocks * (OPJ_UINT32)sizeof_block; 938 939 if (! l_current_precinct->cblks.blocks) { 940 l_current_precinct->cblks.blocks = opj_malloc(l_nb_code_blocks_size); 941 if (! l_current_precinct->cblks.blocks ) { 942 return OPJ_FALSE; 943 } 944 /*fprintf(stderr, "\t\t\t\tAllocate cblks of a precinct (opj_tcd_cblk_dec_t): %d\n",l_nb_code_blocks_size);*/ 945 946 memset(l_current_precinct->cblks.blocks,0,l_nb_code_blocks_size); 947 948 l_current_precinct->block_size = l_nb_code_blocks_size; 949 } 950 else if (l_nb_code_blocks_size > l_current_precinct->block_size) { 951 void *new_blocks = opj_realloc(l_current_precinct->cblks.blocks, l_nb_code_blocks_size); 952 if (! new_blocks) { 953 opj_free(l_current_precinct->cblks.blocks); 954 l_current_precinct->cblks.blocks = NULL; 955 l_current_precinct->block_size = 0; 956 opj_event_msg(manager, EVT_ERROR, "Not enough memory for current precinct codeblock element\n"); 957 return OPJ_FALSE; 958 } 959 l_current_precinct->cblks.blocks = new_blocks; 960 /*fprintf(stderr, "\t\t\t\tReallocate cblks of a precinct (opj_tcd_cblk_dec_t): from %d to %d\n",l_current_precinct->block_size, l_nb_code_blocks_size); */ 961 962 memset(((OPJ_BYTE *) l_current_precinct->cblks.blocks) + l_current_precinct->block_size 963 ,0 964 ,l_nb_code_blocks_size - l_current_precinct->block_size); 965 966 l_current_precinct->block_size = l_nb_code_blocks_size; 967 } 968 969 if (! l_current_precinct->incltree) { 970 l_current_precinct->incltree = opj_tgt_create(l_current_precinct->cw, l_current_precinct->ch, manager); 971 } 972 else{ 973 l_current_precinct->incltree = opj_tgt_init(l_current_precinct->incltree, l_current_precinct->cw, l_current_precinct->ch, manager); 974 } 975 976 if (! l_current_precinct->incltree) { 977 opj_event_msg(manager, EVT_WARNING, "No incltree created.\n"); 978 /*return OPJ_FALSE;*/ 979 } 980 981 if (! l_current_precinct->imsbtree) { 982 l_current_precinct->imsbtree = opj_tgt_create(l_current_precinct->cw, l_current_precinct->ch, manager); 983 } 984 else { 985 l_current_precinct->imsbtree = opj_tgt_init(l_current_precinct->imsbtree, l_current_precinct->cw, l_current_precinct->ch, manager); 986 } 987 988 if (! l_current_precinct->imsbtree) { 989 opj_event_msg(manager, EVT_WARNING, "No imsbtree created.\n"); 990 /*return OPJ_FALSE;*/ 991 } 992 993 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) { 994 OPJ_INT32 cblkxstart = tlcblkxstart + (OPJ_INT32)(cblkno % l_current_precinct->cw) * (1 << cblkwidthexpn); 995 OPJ_INT32 cblkystart = tlcblkystart + (OPJ_INT32)(cblkno / l_current_precinct->cw) * (1 << cblkheightexpn); 996 OPJ_INT32 cblkxend = cblkxstart + (1 << cblkwidthexpn); 997 OPJ_INT32 cblkyend = cblkystart + (1 << cblkheightexpn); 998 999 if (isEncoder) { 1000 opj_tcd_cblk_enc_t* l_code_block = l_current_precinct->cblks.enc + cblkno; 1001 1002 if (! opj_tcd_code_block_enc_allocate(l_code_block)) { 1003 return OPJ_FALSE; 1004 } 1005 /* code-block size (global) */ 1006 l_code_block->x0 = opj_int_max(cblkxstart, l_current_precinct->x0); 1007 l_code_block->y0 = opj_int_max(cblkystart, l_current_precinct->y0); 1008 l_code_block->x1 = opj_int_min(cblkxend, l_current_precinct->x1); 1009 l_code_block->y1 = opj_int_min(cblkyend, l_current_precinct->y1); 1010 1011 if (! opj_tcd_code_block_enc_allocate_data(l_code_block)) { 1012 return OPJ_FALSE; 1013 } 1014 } else { 1015 opj_tcd_cblk_dec_t* l_code_block = l_current_precinct->cblks.dec + cblkno; 1016 1017 if (! opj_tcd_code_block_dec_allocate(l_code_block)) { 1018 return OPJ_FALSE; 1019 } 1020 /* code-block size (global) */ 1021 l_code_block->x0 = opj_int_max(cblkxstart, l_current_precinct->x0); 1022 l_code_block->y0 = opj_int_max(cblkystart, l_current_precinct->y0); 1023 l_code_block->x1 = opj_int_min(cblkxend, l_current_precinct->x1); 1024 l_code_block->y1 = opj_int_min(cblkyend, l_current_precinct->y1); 1025 } 1026 } 1027 ++l_current_precinct; 1028 } /* precno */ 1029 ++l_band; 1030 ++l_step_size; 1031 } /* bandno */ 1032 ++l_res; 1033 --l_level_no; 1034 } /* resno */ 1035 ++l_tccp; 1036 ++l_tilec; 1037 ++l_image_comp; 1038 } /* compno */ 1039 return OPJ_TRUE; 1040} 1041 1042OPJ_BOOL opj_tcd_init_encode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager) 1043{ 1044 return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_TRUE, 1.0F, sizeof(opj_tcd_cblk_enc_t), p_manager); 1045} 1046 1047OPJ_BOOL opj_tcd_init_decode_tile (opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager) 1048{ 1049 return opj_tcd_init_tile(p_tcd, p_tile_no, OPJ_FALSE, 0.5F, sizeof(opj_tcd_cblk_dec_t), p_manager); 1050} 1051 1052/** 1053 * Allocates memory for an encoding code block (but not data memory). 1054 */ 1055static OPJ_BOOL opj_tcd_code_block_enc_allocate (opj_tcd_cblk_enc_t * p_code_block) 1056{ 1057 if (! p_code_block->layers) { 1058 /* no memset since data */ 1059 p_code_block->layers = (opj_tcd_layer_t*) opj_calloc(100, sizeof(opj_tcd_layer_t)); 1060 if (! p_code_block->layers) { 1061 return OPJ_FALSE; 1062 } 1063 } 1064 if (! p_code_block->passes) { 1065 p_code_block->passes = (opj_tcd_pass_t*) opj_calloc(100, sizeof(opj_tcd_pass_t)); 1066 if (! p_code_block->passes) { 1067 return OPJ_FALSE; 1068 } 1069 } 1070 return OPJ_TRUE; 1071} 1072 1073/** 1074 * Allocates data memory for an encoding code block. 1075 */ 1076static OPJ_BOOL opj_tcd_code_block_enc_allocate_data (opj_tcd_cblk_enc_t * p_code_block) 1077{ 1078 OPJ_UINT32 l_data_size; 1079 1080 l_data_size = (OPJ_UINT32)((p_code_block->x1 - p_code_block->x0) * (p_code_block->y1 - p_code_block->y0) * (OPJ_INT32)sizeof(OPJ_UINT32)); 1081 1082 if (l_data_size > p_code_block->data_size) { 1083 if (p_code_block->data) { 1084 opj_free(p_code_block->data - 1); /* again, why -1 */ 1085 } 1086 p_code_block->data = (OPJ_BYTE*) opj_malloc(l_data_size+1); 1087 if(! p_code_block->data) { 1088 p_code_block->data_size = 0U; 1089 return OPJ_FALSE; 1090 } 1091 p_code_block->data_size = l_data_size; 1092 1093 p_code_block->data[0] = 0; 1094 p_code_block->data+=1; /*why +1 ?*/ 1095 } 1096 return OPJ_TRUE; 1097} 1098 1099/** 1100 * Allocates memory for a decoding code block. 1101 */ 1102static OPJ_BOOL opj_tcd_code_block_dec_allocate (opj_tcd_cblk_dec_t * p_code_block) 1103{ 1104 if (! p_code_block->data) { 1105 1106 p_code_block->data = (OPJ_BYTE*) opj_malloc(OPJ_J2K_DEFAULT_CBLK_DATA_SIZE); 1107 if (! p_code_block->data) { 1108 return OPJ_FALSE; 1109 } 1110 p_code_block->data_max_size = OPJ_J2K_DEFAULT_CBLK_DATA_SIZE; 1111 /*fprintf(stderr, "Allocate 8192 elements of code_block->data\n");*/ 1112 1113 p_code_block->segs = (opj_tcd_seg_t *) opj_calloc(OPJ_J2K_DEFAULT_NB_SEGS,sizeof(opj_tcd_seg_t)); 1114 if (! p_code_block->segs) { 1115 return OPJ_FALSE; 1116 } 1117 /*fprintf(stderr, "Allocate %d elements of code_block->data\n", OPJ_J2K_DEFAULT_NB_SEGS * sizeof(opj_tcd_seg_t));*/ 1118 1119 p_code_block->m_current_max_segs = OPJ_J2K_DEFAULT_NB_SEGS; 1120 /*fprintf(stderr, "m_current_max_segs of code_block->data = %d\n", p_code_block->m_current_max_segs);*/ 1121 } else { 1122 /* sanitize */ 1123 OPJ_BYTE* l_data = p_code_block->data; 1124 OPJ_UINT32 l_data_max_size = p_code_block->data_max_size; 1125 opj_tcd_seg_t * l_segs = p_code_block->segs; 1126 OPJ_UINT32 l_current_max_segs = p_code_block->m_current_max_segs; 1127 1128 memset(p_code_block, 0, sizeof(opj_tcd_cblk_dec_t)); 1129 p_code_block->data = l_data; 1130 p_code_block->data_max_size = l_data_max_size; 1131 p_code_block->segs = l_segs; 1132 p_code_block->m_current_max_segs = l_current_max_segs; 1133 } 1134 1135 return OPJ_TRUE; 1136} 1137 1138OPJ_UINT32 opj_tcd_get_decoded_tile_size ( opj_tcd_t *p_tcd ) 1139{ 1140 OPJ_UINT32 i; 1141 OPJ_UINT32 l_data_size = 0; 1142 opj_image_comp_t * l_img_comp = 00; 1143 opj_tcd_tilecomp_t * l_tile_comp = 00; 1144 opj_tcd_resolution_t * l_res = 00; 1145 OPJ_UINT32 l_size_comp, l_remaining; 1146 1147 l_tile_comp = p_tcd->tcd_image->tiles->comps; 1148 l_img_comp = p_tcd->image->comps; 1149 1150 for (i=0;i<p_tcd->image->numcomps;++i) { 1151 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/ 1152 l_remaining = l_img_comp->prec & 7; /* (%8) */ 1153 1154 if(l_remaining) { 1155 ++l_size_comp; 1156 } 1157 1158 if (l_size_comp == 3) { 1159 l_size_comp = 4; 1160 } 1161 1162 l_res = l_tile_comp->resolutions + l_tile_comp->minimum_num_resolutions - 1; 1163 l_data_size += l_size_comp * (OPJ_UINT32)((l_res->x1 - l_res->x0) * (l_res->y1 - l_res->y0)); 1164 ++l_img_comp; 1165 ++l_tile_comp; 1166 } 1167 1168 return l_data_size; 1169} 1170 1171OPJ_BOOL opj_tcd_encode_tile( opj_tcd_t *p_tcd, 1172 OPJ_UINT32 p_tile_no, 1173 OPJ_BYTE *p_dest, 1174 OPJ_UINT32 * p_data_written, 1175 OPJ_UINT32 p_max_length, 1176 opj_codestream_info_t *p_cstr_info) 1177{ 1178 1179 if (p_tcd->cur_tp_num == 0) { 1180 1181 p_tcd->tcd_tileno = p_tile_no; 1182 p_tcd->tcp = &p_tcd->cp->tcps[p_tile_no]; 1183 1184 /* INDEX >> "Precinct_nb_X et Precinct_nb_Y" */ 1185 if(p_cstr_info) { 1186 OPJ_UINT32 l_num_packs = 0; 1187 OPJ_UINT32 i; 1188 opj_tcd_tilecomp_t *l_tilec_idx = &p_tcd->tcd_image->tiles->comps[0]; /* based on component 0 */ 1189 opj_tccp_t *l_tccp = p_tcd->tcp->tccps; /* based on component 0 */ 1190 1191 for (i = 0; i < l_tilec_idx->numresolutions; i++) { 1192 opj_tcd_resolution_t *l_res_idx = &l_tilec_idx->resolutions[i]; 1193 1194 p_cstr_info->tile[p_tile_no].pw[i] = (int)l_res_idx->pw; 1195 p_cstr_info->tile[p_tile_no].ph[i] = (int)l_res_idx->ph; 1196 1197 l_num_packs += l_res_idx->pw * l_res_idx->ph; 1198 p_cstr_info->tile[p_tile_no].pdx[i] = (int)l_tccp->prcw[i]; 1199 p_cstr_info->tile[p_tile_no].pdy[i] = (int)l_tccp->prch[i]; 1200 } 1201 p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t*) opj_calloc((size_t)p_cstr_info->numcomps * (size_t)p_cstr_info->numlayers * l_num_packs, sizeof(opj_packet_info_t)); 1202 if (!p_cstr_info->tile[p_tile_no].packet) { 1203 /* FIXME event manager error callback */ 1204 return OPJ_FALSE; 1205 } 1206 } 1207 /* << INDEX */ 1208 1209 /* FIXME _ProfStart(PGROUP_DC_SHIFT); */ 1210 /*---------------TILE-------------------*/ 1211 if (! opj_tcd_dc_level_shift_encode(p_tcd)) { 1212 return OPJ_FALSE; 1213 } 1214 /* FIXME _ProfStop(PGROUP_DC_SHIFT); */ 1215 1216 /* FIXME _ProfStart(PGROUP_MCT); */ 1217 if (! opj_tcd_mct_encode(p_tcd)) { 1218 return OPJ_FALSE; 1219 } 1220 /* FIXME _ProfStop(PGROUP_MCT); */ 1221 1222 /* FIXME _ProfStart(PGROUP_DWT); */ 1223 if (! opj_tcd_dwt_encode(p_tcd)) { 1224 return OPJ_FALSE; 1225 } 1226 /* FIXME _ProfStop(PGROUP_DWT); */ 1227 1228 /* FIXME _ProfStart(PGROUP_T1); */ 1229 if (! opj_tcd_t1_encode(p_tcd)) { 1230 return OPJ_FALSE; 1231 } 1232 /* FIXME _ProfStop(PGROUP_T1); */ 1233 1234 /* FIXME _ProfStart(PGROUP_RATE); */ 1235 if (! opj_tcd_rate_allocate_encode(p_tcd,p_dest,p_max_length,p_cstr_info)) { 1236 return OPJ_FALSE; 1237 } 1238 /* FIXME _ProfStop(PGROUP_RATE); */ 1239 1240 } 1241 /*--------------TIER2------------------*/ 1242 1243 /* INDEX */ 1244 if (p_cstr_info) { 1245 p_cstr_info->index_write = 1; 1246 } 1247 /* FIXME _ProfStart(PGROUP_T2); */ 1248 1249 if (! opj_tcd_t2_encode(p_tcd,p_dest,p_data_written,p_max_length,p_cstr_info)) { 1250 return OPJ_FALSE; 1251 } 1252 /* FIXME _ProfStop(PGROUP_T2); */ 1253 1254 /*---------------CLEAN-------------------*/ 1255 1256 return OPJ_TRUE; 1257} 1258 1259OPJ_BOOL opj_tcd_decode_tile( opj_tcd_t *p_tcd, 1260 OPJ_BYTE *p_src, 1261 OPJ_UINT32 p_max_length, 1262 OPJ_UINT32 p_tile_no, 1263 opj_codestream_index_t *p_cstr_index, 1264 opj_event_mgr_t *p_manager 1265 ) 1266{ 1267 OPJ_UINT32 l_data_read; 1268 p_tcd->tcd_tileno = p_tile_no; 1269 p_tcd->tcp = &(p_tcd->cp->tcps[p_tile_no]); 1270 1271#ifdef TODO_MSD /* FIXME */ 1272 /* INDEX >> */ 1273 if(p_cstr_info) { 1274 OPJ_UINT32 resno, compno, numprec = 0; 1275 for (compno = 0; compno < (OPJ_UINT32) p_cstr_info->numcomps; compno++) { 1276 opj_tcp_t *tcp = &p_tcd->cp->tcps[0]; 1277 opj_tccp_t *tccp = &tcp->tccps[compno]; 1278 opj_tcd_tilecomp_t *tilec_idx = &p_tcd->tcd_image->tiles->comps[compno]; 1279 for (resno = 0; resno < tilec_idx->numresolutions; resno++) { 1280 opj_tcd_resolution_t *res_idx = &tilec_idx->resolutions[resno]; 1281 p_cstr_info->tile[p_tile_no].pw[resno] = res_idx->pw; 1282 p_cstr_info->tile[p_tile_no].ph[resno] = res_idx->ph; 1283 numprec += res_idx->pw * res_idx->ph; 1284 p_cstr_info->tile[p_tile_no].pdx[resno] = tccp->prcw[resno]; 1285 p_cstr_info->tile[p_tile_no].pdy[resno] = tccp->prch[resno]; 1286 } 1287 } 1288 p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t *) opj_malloc(p_cstr_info->numlayers * numprec * sizeof(opj_packet_info_t)); 1289 p_cstr_info->packno = 0; 1290 } 1291 /* << INDEX */ 1292#endif 1293 1294 /*--------------TIER2------------------*/ 1295 /* FIXME _ProfStart(PGROUP_T2); */ 1296 l_data_read = 0; 1297 if (! opj_tcd_t2_decode(p_tcd, p_src, &l_data_read, p_max_length, p_cstr_index, p_manager)) 1298 { 1299 return OPJ_FALSE; 1300 } 1301 /* FIXME _ProfStop(PGROUP_T2); */ 1302 1303 /*------------------TIER1-----------------*/ 1304 1305 /* FIXME _ProfStart(PGROUP_T1); */ 1306 if 1307 (! opj_tcd_t1_decode(p_tcd)) 1308 { 1309 return OPJ_FALSE; 1310 } 1311 /* FIXME _ProfStop(PGROUP_T1); */ 1312 1313 /*----------------DWT---------------------*/ 1314 1315 /* FIXME _ProfStart(PGROUP_DWT); */ 1316 if 1317 (! opj_tcd_dwt_decode(p_tcd)) 1318 { 1319 return OPJ_FALSE; 1320 } 1321 /* FIXME _ProfStop(PGROUP_DWT); */ 1322 1323 /*----------------MCT-------------------*/ 1324 /* FIXME _ProfStart(PGROUP_MCT); */ 1325 if 1326 (! opj_tcd_mct_decode(p_tcd, p_manager)) 1327 { 1328 return OPJ_FALSE; 1329 } 1330 /* FIXME _ProfStop(PGROUP_MCT); */ 1331 1332 /* FIXME _ProfStart(PGROUP_DC_SHIFT); */ 1333 if 1334 (! opj_tcd_dc_level_shift_decode(p_tcd)) 1335 { 1336 return OPJ_FALSE; 1337 } 1338 /* FIXME _ProfStop(PGROUP_DC_SHIFT); */ 1339 1340 1341 /*---------------TILE-------------------*/ 1342 return OPJ_TRUE; 1343} 1344 1345OPJ_BOOL opj_tcd_update_tile_data ( opj_tcd_t *p_tcd, 1346 OPJ_BYTE * p_dest, 1347 OPJ_UINT32 p_dest_length 1348 ) 1349{ 1350 OPJ_UINT32 i,j,k,l_data_size = 0; 1351 opj_image_comp_t * l_img_comp = 00; 1352 opj_tcd_tilecomp_t * l_tilec = 00; 1353 opj_tcd_resolution_t * l_res; 1354 OPJ_UINT32 l_size_comp, l_remaining; 1355 OPJ_UINT32 l_stride, l_width,l_height; 1356 1357 l_data_size = opj_tcd_get_decoded_tile_size(p_tcd); 1358 if (l_data_size > p_dest_length) { 1359 return OPJ_FALSE; 1360 } 1361 1362 l_tilec = p_tcd->tcd_image->tiles->comps; 1363 l_img_comp = p_tcd->image->comps; 1364 1365 for (i=0;i<p_tcd->image->numcomps;++i) { 1366 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/ 1367 l_remaining = l_img_comp->prec & 7; /* (%8) */ 1368 l_res = l_tilec->resolutions + l_img_comp->resno_decoded; 1369 l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0); 1370 l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0); 1371 l_stride = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0) - l_width; 1372 1373 if (l_remaining) { 1374 ++l_size_comp; 1375 } 1376 1377 if (l_size_comp == 3) { 1378 l_size_comp = 4; 1379 } 1380 1381 switch (l_size_comp) 1382 { 1383 case 1: 1384 { 1385 OPJ_CHAR * l_dest_ptr = (OPJ_CHAR *) p_dest; 1386 const OPJ_INT32 * l_src_ptr = l_tilec->data; 1387 1388 if (l_img_comp->sgnd) { 1389 for (j=0;j<l_height;++j) { 1390 for (k=0;k<l_width;++k) { 1391 *(l_dest_ptr++) = (OPJ_CHAR) (*(l_src_ptr++)); 1392 } 1393 l_src_ptr += l_stride; 1394 } 1395 } 1396 else { 1397 for (j=0;j<l_height;++j) { 1398 for (k=0;k<l_width;++k) { 1399 *(l_dest_ptr++) = (OPJ_CHAR) ((*(l_src_ptr++))&0xff); 1400 } 1401 l_src_ptr += l_stride; 1402 } 1403 } 1404 1405 p_dest = (OPJ_BYTE *)l_dest_ptr; 1406 } 1407 break; 1408 case 2: 1409 { 1410 const OPJ_INT32 * l_src_ptr = l_tilec->data; 1411 OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_dest; 1412 1413 if (l_img_comp->sgnd) { 1414 for (j=0;j<l_height;++j) { 1415 for (k=0;k<l_width;++k) { 1416 *(l_dest_ptr++) = (OPJ_INT16) (*(l_src_ptr++)); 1417 } 1418 l_src_ptr += l_stride; 1419 } 1420 } 1421 else { 1422 for (j=0;j<l_height;++j) { 1423 for (k=0;k<l_width;++k) { 1424 *(l_dest_ptr++) = (OPJ_INT16) ((*(l_src_ptr++))&0xffff); 1425 } 1426 l_src_ptr += l_stride; 1427 } 1428 } 1429 1430 p_dest = (OPJ_BYTE*) l_dest_ptr; 1431 } 1432 break; 1433 case 4: 1434 { 1435 OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_dest; 1436 OPJ_INT32 * l_src_ptr = l_tilec->data; 1437 1438 for (j=0;j<l_height;++j) { 1439 for (k=0;k<l_width;++k) { 1440 *(l_dest_ptr++) = (*(l_src_ptr++)); 1441 } 1442 l_src_ptr += l_stride; 1443 } 1444 1445 p_dest = (OPJ_BYTE*) l_dest_ptr; 1446 } 1447 break; 1448 } 1449 1450 ++l_img_comp; 1451 ++l_tilec; 1452 } 1453 1454 return OPJ_TRUE; 1455} 1456 1457 1458 1459 1460static void opj_tcd_free_tile(opj_tcd_t *p_tcd) 1461{ 1462 OPJ_UINT32 compno, resno, bandno, precno; 1463 opj_tcd_tile_t *l_tile = 00; 1464 opj_tcd_tilecomp_t *l_tile_comp = 00; 1465 opj_tcd_resolution_t *l_res = 00; 1466 opj_tcd_band_t *l_band = 00; 1467 opj_tcd_precinct_t *l_precinct = 00; 1468 OPJ_UINT32 l_nb_resolutions, l_nb_precincts; 1469 void (* l_tcd_code_block_deallocate) (opj_tcd_precinct_t *) = 00; 1470 1471 if (! p_tcd) { 1472 return; 1473 } 1474 1475 if (! p_tcd->tcd_image) { 1476 return; 1477 } 1478 1479 if (p_tcd->m_is_decoder) { 1480 l_tcd_code_block_deallocate = opj_tcd_code_block_dec_deallocate; 1481 } 1482 else { 1483 l_tcd_code_block_deallocate = opj_tcd_code_block_enc_deallocate; 1484 } 1485 1486 l_tile = p_tcd->tcd_image->tiles; 1487 if (! l_tile) { 1488 return; 1489 } 1490 1491 l_tile_comp = l_tile->comps; 1492 1493 for (compno = 0; compno < l_tile->numcomps; ++compno) { 1494 l_res = l_tile_comp->resolutions; 1495 if (l_res) { 1496 1497 l_nb_resolutions = l_tile_comp->resolutions_size / sizeof(opj_tcd_resolution_t); 1498 for (resno = 0; resno < l_nb_resolutions; ++resno) { 1499 l_band = l_res->bands; 1500 for (bandno = 0; bandno < 3; ++bandno) { 1501 l_precinct = l_band->precincts; 1502 if (l_precinct) { 1503 1504 l_nb_precincts = l_band->precincts_data_size / sizeof(opj_tcd_precinct_t); 1505 for (precno = 0; precno < l_nb_precincts; ++precno) { 1506 opj_tgt_destroy(l_precinct->incltree); 1507 l_precinct->incltree = 00; 1508 opj_tgt_destroy(l_precinct->imsbtree); 1509 l_precinct->imsbtree = 00; 1510 (*l_tcd_code_block_deallocate) (l_precinct); 1511 ++l_precinct; 1512 } 1513 1514 opj_free(l_band->precincts); 1515 l_band->precincts = 00; 1516 } 1517 ++l_band; 1518 } /* for (resno */ 1519 ++l_res; 1520 } 1521 1522 opj_free(l_tile_comp->resolutions); 1523 l_tile_comp->resolutions = 00; 1524 } 1525 1526 if (l_tile_comp->ownsData && l_tile_comp->data) { 1527 opj_free(l_tile_comp->data); 1528 l_tile_comp->data = 00; 1529 l_tile_comp->ownsData = 0; 1530 l_tile_comp->data_size = 0; 1531 l_tile_comp->data_size_needed = 0; 1532 } 1533 ++l_tile_comp; 1534 } 1535 1536 opj_free(l_tile->comps); 1537 l_tile->comps = 00; 1538 opj_free(p_tcd->tcd_image->tiles); 1539 p_tcd->tcd_image->tiles = 00; 1540} 1541 1542 1543static OPJ_BOOL opj_tcd_t2_decode (opj_tcd_t *p_tcd, 1544 OPJ_BYTE * p_src_data, 1545 OPJ_UINT32 * p_data_read, 1546 OPJ_UINT32 p_max_src_size, 1547 opj_codestream_index_t *p_cstr_index, 1548 opj_event_mgr_t *p_manager 1549 ) 1550{ 1551 opj_t2_t * l_t2; 1552 1553 l_t2 = opj_t2_create(p_tcd->image, p_tcd->cp); 1554 if (l_t2 == 00) { 1555 return OPJ_FALSE; 1556 } 1557 1558 if (! opj_t2_decode_packets( 1559 l_t2, 1560 p_tcd->tcd_tileno, 1561 p_tcd->tcd_image->tiles, 1562 p_src_data, 1563 p_data_read, 1564 p_max_src_size, 1565 p_cstr_index, 1566 p_manager)) { 1567 opj_t2_destroy(l_t2); 1568 return OPJ_FALSE; 1569 } 1570 1571 opj_t2_destroy(l_t2); 1572 1573 /*---------------CLEAN-------------------*/ 1574 return OPJ_TRUE; 1575} 1576 1577static OPJ_BOOL opj_tcd_t1_decode ( opj_tcd_t *p_tcd ) 1578{ 1579 OPJ_UINT32 compno; 1580 opj_t1_t * l_t1; 1581 opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles; 1582 opj_tcd_tilecomp_t* l_tile_comp = l_tile->comps; 1583 opj_tccp_t * l_tccp = p_tcd->tcp->tccps; 1584 1585 1586 l_t1 = opj_t1_create(OPJ_FALSE); 1587 if (l_t1 == 00) { 1588 return OPJ_FALSE; 1589 } 1590 1591 for (compno = 0; compno < l_tile->numcomps; ++compno) { 1592 /* The +3 is headroom required by the vectorized DWT */ 1593 if (OPJ_FALSE == opj_t1_decode_cblks(l_t1, l_tile_comp, l_tccp)) { 1594 opj_t1_destroy(l_t1); 1595 return OPJ_FALSE; 1596 } 1597 ++l_tile_comp; 1598 ++l_tccp; 1599 } 1600 1601 opj_t1_destroy(l_t1); 1602 1603 return OPJ_TRUE; 1604} 1605 1606 1607static OPJ_BOOL opj_tcd_dwt_decode ( opj_tcd_t *p_tcd ) 1608{ 1609 OPJ_UINT32 compno; 1610 opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles; 1611 opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps; 1612 opj_tccp_t * l_tccp = p_tcd->tcp->tccps; 1613 opj_image_comp_t * l_img_comp = p_tcd->image->comps; 1614 1615 for (compno = 0; compno < l_tile->numcomps; compno++) { 1616 /* 1617 if (tcd->cp->reduce != 0) { 1618 tcd->image->comps[compno].resno_decoded = 1619 tile->comps[compno].numresolutions - tcd->cp->reduce - 1; 1620 if (tcd->image->comps[compno].resno_decoded < 0) 1621 { 1622 return false; 1623 } 1624 } 1625 numres2decode = tcd->image->comps[compno].resno_decoded + 1; 1626 if(numres2decode > 0){ 1627 */ 1628 1629 if (l_tccp->qmfbid == 1) { 1630 if (! opj_dwt_decode(l_tile_comp, l_img_comp->resno_decoded+1)) { 1631 return OPJ_FALSE; 1632 } 1633 } 1634 else { 1635 if (! opj_dwt_decode_real(l_tile_comp, l_img_comp->resno_decoded+1)) { 1636 return OPJ_FALSE; 1637 } 1638 } 1639 1640 ++l_tile_comp; 1641 ++l_img_comp; 1642 ++l_tccp; 1643 } 1644 1645 return OPJ_TRUE; 1646} 1647static OPJ_BOOL opj_tcd_mct_decode ( opj_tcd_t *p_tcd, opj_event_mgr_t *p_manager) 1648{ 1649 opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles; 1650 opj_tcp_t * l_tcp = p_tcd->tcp; 1651 opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps; 1652 OPJ_UINT32 l_samples,i; 1653 1654 if (! l_tcp->mct) { 1655 return OPJ_TRUE; 1656 } 1657 1658 l_samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0)); 1659 1660 if (l_tile->numcomps >= 3 ){ 1661 /* testcase 1336.pdf.asan.47.376 */ 1662 if ((l_tile->comps[0].x1 - l_tile->comps[0].x0) * (l_tile->comps[0].y1 - l_tile->comps[0].y0) < (OPJ_INT32)l_samples || 1663 (l_tile->comps[1].x1 - l_tile->comps[1].x0) * (l_tile->comps[1].y1 - l_tile->comps[1].y0) < (OPJ_INT32)l_samples || 1664 (l_tile->comps[2].x1 - l_tile->comps[2].x0) * (l_tile->comps[2].y1 - l_tile->comps[2].y0) < (OPJ_INT32)l_samples) { 1665 opj_event_msg(p_manager, EVT_ERROR, "Tiles don't all have the same dimension. Skip the MCT step.\n"); 1666 return OPJ_FALSE; 1667 } 1668 else if (l_tcp->mct == 2) { 1669 OPJ_BYTE ** l_data; 1670 1671 if (! l_tcp->m_mct_decoding_matrix) { 1672 return OPJ_TRUE; 1673 } 1674 1675 l_data = (OPJ_BYTE **) opj_malloc(l_tile->numcomps*sizeof(OPJ_BYTE*)); 1676 if (! l_data) { 1677 return OPJ_FALSE; 1678 } 1679 1680 for (i=0;i<l_tile->numcomps;++i) { 1681 l_data[i] = (OPJ_BYTE*) l_tile_comp->data; 1682 ++l_tile_comp; 1683 } 1684 1685 if (! opj_mct_decode_custom(/* MCT data */ 1686 (OPJ_BYTE*) l_tcp->m_mct_decoding_matrix, 1687 /* size of components */ 1688 l_samples, 1689 /* components */ 1690 l_data, 1691 /* nb of components (i.e. size of pData) */ 1692 l_tile->numcomps, 1693 /* tells if the data is signed */ 1694 p_tcd->image->comps->sgnd)) { 1695 opj_free(l_data); 1696 return OPJ_FALSE; 1697 } 1698 1699 opj_free(l_data); 1700 } 1701 else { 1702 if (l_tcp->tccps->qmfbid == 1) { 1703 opj_mct_decode( l_tile->comps[0].data, 1704 l_tile->comps[1].data, 1705 l_tile->comps[2].data, 1706 l_samples); 1707 } 1708 else { 1709 opj_mct_decode_real((OPJ_FLOAT32*)l_tile->comps[0].data, 1710 (OPJ_FLOAT32*)l_tile->comps[1].data, 1711 (OPJ_FLOAT32*)l_tile->comps[2].data, 1712 l_samples); 1713 } 1714 } 1715 } 1716 else { 1717 opj_event_msg(p_manager, EVT_ERROR, "Number of components (%d) is inconsistent with a MCT. Skip the MCT step.\n",l_tile->numcomps); 1718 } 1719 1720 return OPJ_TRUE; 1721} 1722 1723 1724static OPJ_BOOL opj_tcd_dc_level_shift_decode ( opj_tcd_t *p_tcd ) 1725{ 1726 OPJ_UINT32 compno; 1727 opj_tcd_tilecomp_t * l_tile_comp = 00; 1728 opj_tccp_t * l_tccp = 00; 1729 opj_image_comp_t * l_img_comp = 00; 1730 opj_tcd_resolution_t* l_res = 00; 1731 opj_tcd_tile_t * l_tile; 1732 OPJ_UINT32 l_width,l_height,i,j; 1733 OPJ_INT32 * l_current_ptr; 1734 OPJ_INT32 l_min, l_max; 1735 OPJ_UINT32 l_stride; 1736 1737 l_tile = p_tcd->tcd_image->tiles; 1738 l_tile_comp = l_tile->comps; 1739 l_tccp = p_tcd->tcp->tccps; 1740 l_img_comp = p_tcd->image->comps; 1741 1742 for (compno = 0; compno < l_tile->numcomps; compno++) { 1743 l_res = l_tile_comp->resolutions + l_img_comp->resno_decoded; 1744 l_width = (OPJ_UINT32)(l_res->x1 - l_res->x0); 1745 l_height = (OPJ_UINT32)(l_res->y1 - l_res->y0); 1746 l_stride = (OPJ_UINT32)(l_tile_comp->x1 - l_tile_comp->x0) - l_width; 1747 1748 assert(l_height == 0 || l_width + l_stride <= l_tile_comp->data_size / l_height); /*MUPDF*/ 1749 1750 if (l_img_comp->sgnd) { 1751 l_min = -(1 << (l_img_comp->prec - 1)); 1752 l_max = (1 << (l_img_comp->prec - 1)) - 1; 1753 } 1754 else { 1755 l_min = 0; 1756 l_max = (1 << l_img_comp->prec) - 1; 1757 } 1758 1759 l_current_ptr = l_tile_comp->data; 1760 1761 if (l_tccp->qmfbid == 1) { 1762 for (j=0;j<l_height;++j) { 1763 for (i = 0; i < l_width; ++i) { 1764 *l_current_ptr = opj_int_clamp(*l_current_ptr + l_tccp->m_dc_level_shift, l_min, l_max); 1765 ++l_current_ptr; 1766 } 1767 l_current_ptr += l_stride; 1768 } 1769 } 1770 else { 1771 for (j=0;j<l_height;++j) { 1772 for (i = 0; i < l_width; ++i) { 1773 OPJ_FLOAT32 l_value = *((OPJ_FLOAT32 *) l_current_ptr); 1774 *l_current_ptr = opj_int_clamp((OPJ_INT32)opj_lrintf(l_value) + l_tccp->m_dc_level_shift, l_min, l_max); ; 1775 ++l_current_ptr; 1776 } 1777 l_current_ptr += l_stride; 1778 } 1779 } 1780 1781 ++l_img_comp; 1782 ++l_tccp; 1783 ++l_tile_comp; 1784 } 1785 1786 return OPJ_TRUE; 1787} 1788 1789 1790 1791/** 1792 * Deallocates the encoding data of the given precinct. 1793 */ 1794static void opj_tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct) 1795{ 1796 OPJ_UINT32 cblkno , l_nb_code_blocks; 1797 1798 opj_tcd_cblk_dec_t * l_code_block = p_precinct->cblks.dec; 1799 if (l_code_block) { 1800 /*fprintf(stderr,"deallocate codeblock:{\n");*/ 1801 /*fprintf(stderr,"\t x0=%d, y0=%d, x1=%d, y1=%d\n",l_code_block->x0, l_code_block->y0, l_code_block->x1, l_code_block->y1);*/ 1802 /*fprintf(stderr,"\t numbps=%d, numlenbits=%d, len=%d, numnewpasses=%d, real_num_segs=%d, m_current_max_segs=%d\n ", 1803 l_code_block->numbps, l_code_block->numlenbits, l_code_block->len, l_code_block->numnewpasses, l_code_block->real_num_segs, l_code_block->m_current_max_segs );*/ 1804 1805 1806 l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_dec_t); 1807 /*fprintf(stderr,"nb_code_blocks =%d\t}\n", l_nb_code_blocks);*/ 1808 1809 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) { 1810 1811 if (l_code_block->data) { 1812 opj_free(l_code_block->data); 1813 l_code_block->data = 00; 1814 } 1815 1816 if (l_code_block->segs) { 1817 opj_free(l_code_block->segs ); 1818 l_code_block->segs = 00; 1819 } 1820 1821 ++l_code_block; 1822 } 1823 1824 opj_free(p_precinct->cblks.dec); 1825 p_precinct->cblks.dec = 00; 1826 } 1827} 1828 1829/** 1830 * Deallocates the encoding data of the given precinct. 1831 */ 1832static void opj_tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct) 1833{ 1834 OPJ_UINT32 cblkno , l_nb_code_blocks; 1835 1836 opj_tcd_cblk_enc_t * l_code_block = p_precinct->cblks.enc; 1837 if (l_code_block) { 1838 l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_enc_t); 1839 1840 for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) { 1841 if (l_code_block->data) { 1842 opj_free(l_code_block->data - 1); 1843 l_code_block->data = 00; 1844 } 1845 1846 if (l_code_block->layers) { 1847 opj_free(l_code_block->layers ); 1848 l_code_block->layers = 00; 1849 } 1850 1851 if (l_code_block->passes) { 1852 opj_free(l_code_block->passes ); 1853 l_code_block->passes = 00; 1854 } 1855 ++l_code_block; 1856 } 1857 1858 opj_free(p_precinct->cblks.enc); 1859 1860 p_precinct->cblks.enc = 00; 1861 } 1862} 1863 1864OPJ_UINT32 opj_tcd_get_encoded_tile_size ( opj_tcd_t *p_tcd ) 1865{ 1866 OPJ_UINT32 i,l_data_size = 0; 1867 opj_image_comp_t * l_img_comp = 00; 1868 opj_tcd_tilecomp_t * l_tilec = 00; 1869 OPJ_UINT32 l_size_comp, l_remaining; 1870 1871 l_tilec = p_tcd->tcd_image->tiles->comps; 1872 l_img_comp = p_tcd->image->comps; 1873 for (i=0;i<p_tcd->image->numcomps;++i) { 1874 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/ 1875 l_remaining = l_img_comp->prec & 7; /* (%8) */ 1876 1877 if (l_remaining) { 1878 ++l_size_comp; 1879 } 1880 1881 if (l_size_comp == 3) { 1882 l_size_comp = 4; 1883 } 1884 1885 l_data_size += l_size_comp * (OPJ_UINT32)((l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 - l_tilec->y0)); 1886 ++l_img_comp; 1887 ++l_tilec; 1888 } 1889 1890 return l_data_size; 1891} 1892 1893static OPJ_BOOL opj_tcd_dc_level_shift_encode ( opj_tcd_t *p_tcd ) 1894{ 1895 OPJ_UINT32 compno; 1896 opj_tcd_tilecomp_t * l_tile_comp = 00; 1897 opj_tccp_t * l_tccp = 00; 1898 opj_image_comp_t * l_img_comp = 00; 1899 opj_tcd_tile_t * l_tile; 1900 OPJ_UINT32 l_nb_elem,i; 1901 OPJ_INT32 * l_current_ptr; 1902 1903 l_tile = p_tcd->tcd_image->tiles; 1904 l_tile_comp = l_tile->comps; 1905 l_tccp = p_tcd->tcp->tccps; 1906 l_img_comp = p_tcd->image->comps; 1907 1908 for (compno = 0; compno < l_tile->numcomps; compno++) { 1909 l_current_ptr = l_tile_comp->data; 1910 l_nb_elem = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0)); 1911 1912 if (l_tccp->qmfbid == 1) { 1913 for (i = 0; i < l_nb_elem; ++i) { 1914 *l_current_ptr -= l_tccp->m_dc_level_shift ; 1915 ++l_current_ptr; 1916 } 1917 } 1918 else { 1919 for (i = 0; i < l_nb_elem; ++i) { 1920 *l_current_ptr = (*l_current_ptr - l_tccp->m_dc_level_shift) << 11 ; 1921 ++l_current_ptr; 1922 } 1923 } 1924 1925 ++l_img_comp; 1926 ++l_tccp; 1927 ++l_tile_comp; 1928 } 1929 1930 return OPJ_TRUE; 1931} 1932 1933static OPJ_BOOL opj_tcd_mct_encode ( opj_tcd_t *p_tcd ) 1934{ 1935 opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles; 1936 opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps; 1937 OPJ_UINT32 samples = (OPJ_UINT32)((l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0)); 1938 OPJ_UINT32 i; 1939 OPJ_BYTE ** l_data = 00; 1940 opj_tcp_t * l_tcp = p_tcd->tcp; 1941 1942 if(!p_tcd->tcp->mct) { 1943 return OPJ_TRUE; 1944 } 1945 1946 if (p_tcd->tcp->mct == 2) { 1947 if (! p_tcd->tcp->m_mct_coding_matrix) { 1948 return OPJ_TRUE; 1949 } 1950 1951 l_data = (OPJ_BYTE **) opj_malloc(l_tile->numcomps*sizeof(OPJ_BYTE*)); 1952 if (! l_data) { 1953 return OPJ_FALSE; 1954 } 1955 1956 for (i=0;i<l_tile->numcomps;++i) { 1957 l_data[i] = (OPJ_BYTE*) l_tile_comp->data; 1958 ++l_tile_comp; 1959 } 1960 1961 if (! opj_mct_encode_custom(/* MCT data */ 1962 (OPJ_BYTE*) p_tcd->tcp->m_mct_coding_matrix, 1963 /* size of components */ 1964 samples, 1965 /* components */ 1966 l_data, 1967 /* nb of components (i.e. size of pData) */ 1968 l_tile->numcomps, 1969 /* tells if the data is signed */ 1970 p_tcd->image->comps->sgnd) ) 1971 { 1972 opj_free(l_data); 1973 return OPJ_FALSE; 1974 } 1975 1976 opj_free(l_data); 1977 } 1978 else if (l_tcp->tccps->qmfbid == 0) { 1979 opj_mct_encode_real(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples); 1980 } 1981 else { 1982 opj_mct_encode(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples); 1983 } 1984 1985 return OPJ_TRUE; 1986} 1987 1988static OPJ_BOOL opj_tcd_dwt_encode ( opj_tcd_t *p_tcd ) 1989{ 1990 opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles; 1991 opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps; 1992 opj_tccp_t * l_tccp = p_tcd->tcp->tccps; 1993 OPJ_UINT32 compno; 1994 1995 for (compno = 0; compno < l_tile->numcomps; ++compno) { 1996 if (l_tccp->qmfbid == 1) { 1997 if (! opj_dwt_encode(l_tile_comp)) { 1998 return OPJ_FALSE; 1999 } 2000 } 2001 else if (l_tccp->qmfbid == 0) { 2002 if (! opj_dwt_encode_real(l_tile_comp)) { 2003 return OPJ_FALSE; 2004 } 2005 } 2006 2007 ++l_tile_comp; 2008 ++l_tccp; 2009 } 2010 2011 return OPJ_TRUE; 2012} 2013 2014static OPJ_BOOL opj_tcd_t1_encode ( opj_tcd_t *p_tcd ) 2015{ 2016 opj_t1_t * l_t1; 2017 const OPJ_FLOAT64 * l_mct_norms; 2018 OPJ_UINT32 l_mct_numcomps = 0U; 2019 opj_tcp_t * l_tcp = p_tcd->tcp; 2020 2021 l_t1 = opj_t1_create(OPJ_TRUE); 2022 if (l_t1 == 00) { 2023 return OPJ_FALSE; 2024 } 2025 2026 if (l_tcp->mct == 1) { 2027 l_mct_numcomps = 3U; 2028 /* irreversible encoding */ 2029 if (l_tcp->tccps->qmfbid == 0) { 2030 l_mct_norms = opj_mct_get_mct_norms_real(); 2031 } 2032 else { 2033 l_mct_norms = opj_mct_get_mct_norms(); 2034 } 2035 } 2036 else { 2037 l_mct_numcomps = p_tcd->image->numcomps; 2038 l_mct_norms = (const OPJ_FLOAT64 *) (l_tcp->mct_norms); 2039 } 2040 2041 if (! opj_t1_encode_cblks(l_t1, p_tcd->tcd_image->tiles , l_tcp, l_mct_norms, l_mct_numcomps)) { 2042 opj_t1_destroy(l_t1); 2043 return OPJ_FALSE; 2044 } 2045 2046 opj_t1_destroy(l_t1); 2047 2048 return OPJ_TRUE; 2049} 2050 2051static OPJ_BOOL opj_tcd_t2_encode (opj_tcd_t *p_tcd, 2052 OPJ_BYTE * p_dest_data, 2053 OPJ_UINT32 * p_data_written, 2054 OPJ_UINT32 p_max_dest_size, 2055 opj_codestream_info_t *p_cstr_info ) 2056{ 2057 opj_t2_t * l_t2; 2058 2059 l_t2 = opj_t2_create(p_tcd->image, p_tcd->cp); 2060 if (l_t2 == 00) { 2061 return OPJ_FALSE; 2062 } 2063 2064 if (! opj_t2_encode_packets( 2065 l_t2, 2066 p_tcd->tcd_tileno, 2067 p_tcd->tcd_image->tiles, 2068 p_tcd->tcp->numlayers, 2069 p_dest_data, 2070 p_data_written, 2071 p_max_dest_size, 2072 p_cstr_info, 2073 p_tcd->tp_num, 2074 p_tcd->tp_pos, 2075 p_tcd->cur_pino, 2076 FINAL_PASS)) 2077 { 2078 opj_t2_destroy(l_t2); 2079 return OPJ_FALSE; 2080 } 2081 2082 opj_t2_destroy(l_t2); 2083 2084 /*---------------CLEAN-------------------*/ 2085 return OPJ_TRUE; 2086} 2087 2088 2089static OPJ_BOOL opj_tcd_rate_allocate_encode( opj_tcd_t *p_tcd, 2090 OPJ_BYTE * p_dest_data, 2091 OPJ_UINT32 p_max_dest_size, 2092 opj_codestream_info_t *p_cstr_info ) 2093{ 2094 opj_cp_t * l_cp = p_tcd->cp; 2095 OPJ_UINT32 l_nb_written = 0; 2096 2097 if (p_cstr_info) { 2098 p_cstr_info->index_write = 0; 2099 } 2100 2101 if (l_cp->m_specific_param.m_enc.m_disto_alloc|| l_cp->m_specific_param.m_enc.m_fixed_quality) { 2102 /* fixed_quality */ 2103 /* Normal Rate/distortion allocation */ 2104 if (! opj_tcd_rateallocate(p_tcd, p_dest_data,&l_nb_written, p_max_dest_size, p_cstr_info)) { 2105 return OPJ_FALSE; 2106 } 2107 } 2108 else { 2109 /* Fixed layer allocation */ 2110 opj_tcd_rateallocate_fixed(p_tcd); 2111 } 2112 2113 return OPJ_TRUE; 2114} 2115 2116 2117OPJ_BOOL opj_tcd_copy_tile_data ( opj_tcd_t *p_tcd, 2118 OPJ_BYTE * p_src, 2119 OPJ_UINT32 p_src_length ) 2120{ 2121 OPJ_UINT32 i,j,l_data_size = 0; 2122 opj_image_comp_t * l_img_comp = 00; 2123 opj_tcd_tilecomp_t * l_tilec = 00; 2124 OPJ_UINT32 l_size_comp, l_remaining; 2125 OPJ_UINT32 l_nb_elem; 2126 2127 l_data_size = opj_tcd_get_encoded_tile_size(p_tcd); 2128 if (l_data_size != p_src_length) { 2129 return OPJ_FALSE; 2130 } 2131 2132 l_tilec = p_tcd->tcd_image->tiles->comps; 2133 l_img_comp = p_tcd->image->comps; 2134 for (i=0;i<p_tcd->image->numcomps;++i) { 2135 l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/ 2136 l_remaining = l_img_comp->prec & 7; /* (%8) */ 2137 l_nb_elem = (OPJ_UINT32)((l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 - l_tilec->y0)); 2138 2139 if (l_remaining) { 2140 ++l_size_comp; 2141 } 2142 2143 if (l_size_comp == 3) { 2144 l_size_comp = 4; 2145 } 2146 2147 switch (l_size_comp) { 2148 case 1: 2149 { 2150 OPJ_CHAR * l_src_ptr = (OPJ_CHAR *) p_src; 2151 OPJ_INT32 * l_dest_ptr = l_tilec->data; 2152 2153 if (l_img_comp->sgnd) { 2154 for (j=0;j<l_nb_elem;++j) { 2155 *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); 2156 } 2157 } 2158 else { 2159 for (j=0;j<l_nb_elem;++j) { 2160 *(l_dest_ptr++) = (*(l_src_ptr++))&0xff; 2161 } 2162 } 2163 2164 p_src = (OPJ_BYTE*) l_src_ptr; 2165 } 2166 break; 2167 case 2: 2168 { 2169 OPJ_INT32 * l_dest_ptr = l_tilec->data; 2170 OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_src; 2171 2172 if (l_img_comp->sgnd) { 2173 for (j=0;j<l_nb_elem;++j) { 2174 *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); 2175 } 2176 } 2177 else { 2178 for (j=0;j<l_nb_elem;++j) { 2179 *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff; 2180 } 2181 } 2182 2183 p_src = (OPJ_BYTE*) l_src_ptr; 2184 } 2185 break; 2186 case 4: 2187 { 2188 OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_src; 2189 OPJ_INT32 * l_dest_ptr = l_tilec->data; 2190 2191 for (j=0;j<l_nb_elem;++j) { 2192 *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); 2193 } 2194 2195 p_src = (OPJ_BYTE*) l_src_ptr; 2196 } 2197 break; 2198 } 2199 2200 ++l_img_comp; 2201 ++l_tilec; 2202 } 2203 2204 return OPJ_TRUE; 2205} 2206