git.maemo.org Git - opencv/blob - 3rdparty/libjasper/jpc_enc.c

   1 /*
   2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
   3  *   British Columbia.
   4  * Copyright (c) 2001-2003 Michael David Adams.
   5  * All rights reserved.
   6  */
   7
   8 /* __START_OF_JASPER_LICENSE__
   9  *
  10  * JasPer License Version 2.0
  11  *
  12  * Copyright (c) 2001-2006 Michael David Adams
  13  * Copyright (c) 1999-2000 Image Power, Inc.
  14  * Copyright (c) 1999-2000 The University of British Columbia
  15  *
  16  * All rights reserved.
  17  *
  18  * Permission is hereby granted, free of charge, to any person (the
  19  * "User") obtaining a copy of this software and associated documentation
  20  * files (the "Software"), to deal in the Software without restriction,
  21  * including without limitation the rights to use, copy, modify, merge,
  22  * publish, distribute, and/or sell copies of the Software, and to permit
  23  * persons to whom the Software is furnished to do so, subject to the
  24  * following conditions:
  25  *
  26  * 1.  The above copyright notices and this permission notice (which
  27  * includes the disclaimer below) shall be included in all copies or
  28  * substantial portions of the Software.
  29  *
  30  * 2.  The name of a copyright holder shall not be used to endorse or
  31  * promote products derived from the Software without specific prior
  32  * written permission.
  33  *
  34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  60  *
  61  * __END_OF_JASPER_LICENSE__
  62  */
  63
  64 /*
  65  * $Id: jpc_enc.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
  66  */
  67
  68 /******************************************************************************\
  69 * Includes.
  70 \******************************************************************************/
  71
  72 #include <stdio.h>
  73 #include <stdlib.h>
  74 #include <assert.h>
  75 #include <math.h>
  76 #include <float.h>
  77
  78 #include "jasper/jas_types.h"
  79 #include "jasper/jas_string.h"
  80 #include "jasper/jas_malloc.h"
  81 #include "jasper/jas_image.h"
  82 #include "jasper/jas_fix.h"
  83 #include "jasper/jas_tvp.h"
  84 #include "jasper/jas_version.h"
  85 #include "jasper/jas_math.h"
  86 #include "jasper/jas_debug.h"
  87
  88 #include "jpc_flt.h"
  89 #include "jpc_fix.h"
  90 #include "jpc_tagtree.h"
  91 #include "jpc_enc.h"
  92 #include "jpc_cs.h"
  93 #include "jpc_mct.h"
  94 #include "jpc_tsfb.h"
  95 #include "jpc_qmfb.h"
  96 #include "jpc_t1enc.h"
  97 #include "jpc_t2enc.h"
  98 #include "jpc_cod.h"
  99 #include "jpc_math.h"
 100 #include "jpc_util.h"
 101
 102 /******************************************************************************\
 103 *
 104 \******************************************************************************/
 105
 106 #define JPC_POW2(n) \
 107         (1 << (n))
 108
 109 #define JPC_FLOORTOMULTPOW2(x, n) \
 110   (((n) > 0) ? ((x) & (~((1 << n) - 1))) : (x))
 111 /* Round to the nearest multiple of the specified power of two in the
 112   direction of negative infinity. */
 113
 114 #define JPC_CEILTOMULTPOW2(x, n) \
 115   (((n) > 0) ? JPC_FLOORTOMULTPOW2(((x) + (1 << (n)) - 1), n) : (x))
 116 /* Round to the nearest multiple of the specified power of two in the
 117   direction of positive infinity. */
 118
 119 #define JPC_POW2(n)     \
 120   (1 << (n))
 121
 122 jpc_enc_tile_t *jpc_enc_tile_create(jpc_enc_cp_t *cp, jas_image_t *image, int tileno);
 123 void jpc_enc_tile_destroy(jpc_enc_tile_t *tile);
 124
 125 static jpc_enc_tcmpt_t *tcmpt_create(jpc_enc_tcmpt_t *tcmpt, jpc_enc_cp_t *cp,
 126   jas_image_t *image, jpc_enc_tile_t *tile);
 127 static void tcmpt_destroy(jpc_enc_tcmpt_t *tcmpt);
 128 static jpc_enc_rlvl_t *rlvl_create(jpc_enc_rlvl_t *rlvl, jpc_enc_cp_t *cp,
 129   jpc_enc_tcmpt_t *tcmpt, jpc_tsfb_band_t *bandinfos);
 130 static void rlvl_destroy(jpc_enc_rlvl_t *rlvl);
 131 static jpc_enc_band_t *band_create(jpc_enc_band_t *band, jpc_enc_cp_t *cp,
 132   jpc_enc_rlvl_t *rlvl, jpc_tsfb_band_t *bandinfos);
 133 static void band_destroy(jpc_enc_band_t *bands);
 134 static jpc_enc_prc_t *prc_create(jpc_enc_prc_t *prc, jpc_enc_cp_t *cp,
 135   jpc_enc_band_t *band);
 136 static void prc_destroy(jpc_enc_prc_t *prcs);
 137 static jpc_enc_cblk_t *cblk_create(jpc_enc_cblk_t *cblk, jpc_enc_cp_t *cp,
 138   jpc_enc_prc_t *prc);
 139 static void cblk_destroy(jpc_enc_cblk_t *cblks);
 140 int ratestrtosize(char *s, uint_fast32_t rawsize, uint_fast32_t *size);
 141 static void pass_destroy(jpc_enc_pass_t *pass);
 142 void jpc_enc_dump(jpc_enc_t *enc);
 143
 144 /******************************************************************************\
 145 * Local prototypes.
 146 \******************************************************************************/
 147
 148 int dump_passes(jpc_enc_pass_t *passes, int numpasses, jpc_enc_cblk_t *cblk);
 149 void calcrdslopes(jpc_enc_cblk_t *cblk);
 150 void dump_layeringinfo(jpc_enc_t *enc);
 151 static int jpc_calcssexp(jpc_fix_t stepsize);
 152 static int jpc_calcssmant(jpc_fix_t stepsize);
 153 void jpc_quantize(jas_matrix_t *data, jpc_fix_t stepsize);
 154 static int jpc_enc_encodemainhdr(jpc_enc_t *enc);
 155 static int jpc_enc_encodemainbody(jpc_enc_t *enc);
 156 int jpc_enc_encodetiledata(jpc_enc_t *enc);
 157 jpc_enc_t *jpc_enc_create(jpc_enc_cp_t *cp, jas_stream_t *out, jas_image_t *image);
 158 void jpc_enc_destroy(jpc_enc_t *enc);
 159 static int jpc_enc_encodemainhdr(jpc_enc_t *enc);
 160 static int jpc_enc_encodemainbody(jpc_enc_t *enc);
 161 int jpc_enc_encodetiledata(jpc_enc_t *enc);
 162 int rateallocate(jpc_enc_t *enc, int numlyrs, uint_fast32_t *cumlens);
 163 int setins(int numvalues, jpc_flt_t *values, jpc_flt_t value);
 164 static jpc_enc_cp_t *cp_create(char *optstr, jas_image_t *image);
 165 void jpc_enc_cp_destroy(jpc_enc_cp_t *cp);
 166 static uint_fast32_t jpc_abstorelstepsize(jpc_fix_t absdelta, int scaleexpn);
 167
 168 static uint_fast32_t jpc_abstorelstepsize(jpc_fix_t absdelta, int scaleexpn)
 169 {
 170         int p;
 171         uint_fast32_t mant;
 172         uint_fast32_t expn;
 173         int n;
 174
 175         if (absdelta < 0) {
 176                 abort();
 177         }
 178
 179         p = jpc_firstone(absdelta) - JPC_FIX_FRACBITS;
 180         n = 11 - jpc_firstone(absdelta);
 181         mant = ((n < 0) ? (absdelta >> (-n)) : (absdelta << n)) & 0x7ff;
 182         expn = scaleexpn - p;
 183         if (scaleexpn < p) {
 184                 abort();
 185         }
 186         return JPC_QCX_EXPN(expn) | JPC_QCX_MANT(mant);
 187 }
 188
 189 typedef enum {
 190         OPT_DEBUG,
 191         OPT_IMGAREAOFFX,
 192         OPT_IMGAREAOFFY,
 193         OPT_TILEGRDOFFX,
 194         OPT_TILEGRDOFFY,
 195         OPT_TILEWIDTH,
 196         OPT_TILEHEIGHT,
 197         OPT_PRCWIDTH,
 198         OPT_PRCHEIGHT,
 199         OPT_CBLKWIDTH,
 200         OPT_CBLKHEIGHT,
 201         OPT_MODE,
 202         OPT_PRG,
 203         OPT_NOMCT,
 204         OPT_MAXRLVLS,
 205         OPT_SOP,
 206         OPT_EPH,
 207         OPT_LAZY,
 208         OPT_TERMALL,
 209         OPT_SEGSYM,
 210         OPT_VCAUSAL,
 211         OPT_RESET,
 212         OPT_PTERM,
 213         OPT_NUMGBITS,
 214         OPT_RATE,
 215         OPT_ILYRRATES,
 216         OPT_JP2OVERHEAD
 217 } optid_t;
 218
 219 jas_taginfo_t encopts[] = {
 220         {OPT_DEBUG, "debug"},
 221         {OPT_IMGAREAOFFX, "imgareatlx"},
 222         {OPT_IMGAREAOFFY, "imgareatly"},
 223         {OPT_TILEGRDOFFX, "tilegrdtlx"},
 224         {OPT_TILEGRDOFFY, "tilegrdtly"},
 225         {OPT_TILEWIDTH, "tilewidth"},
 226         {OPT_TILEHEIGHT, "tileheight"},
 227         {OPT_PRCWIDTH, "prcwidth"},
 228         {OPT_PRCHEIGHT, "prcheight"},
 229         {OPT_CBLKWIDTH, "cblkwidth"},
 230         {OPT_CBLKHEIGHT, "cblkheight"},
 231         {OPT_MODE, "mode"},
 232         {OPT_PRG, "prg"},
 233         {OPT_NOMCT, "nomct"},
 234         {OPT_MAXRLVLS, "numrlvls"},
 235         {OPT_SOP, "sop"},
 236         {OPT_EPH, "eph"},
 237         {OPT_LAZY, "lazy"},
 238         {OPT_TERMALL, "termall"},
 239         {OPT_SEGSYM, "segsym"},
 240         {OPT_VCAUSAL, "vcausal"},
 241         {OPT_PTERM, "pterm"},
 242         {OPT_RESET, "resetprob"},
 243         {OPT_NUMGBITS, "numgbits"},
 244         {OPT_RATE, "rate"},
 245         {OPT_ILYRRATES, "ilyrrates"},
 246         {OPT_JP2OVERHEAD, "_jp2overhead"},
 247         {-1, 0}
 248 };
 249
 250 typedef enum {
 251         PO_L = 0,
 252         PO_R
 253 } poid_t;
 254
 255
 256 jas_taginfo_t prgordtab[] = {
 257         {JPC_COD_LRCPPRG, "lrcp"},
 258         {JPC_COD_RLCPPRG, "rlcp"},
 259         {JPC_COD_RPCLPRG, "rpcl"},
 260         {JPC_COD_PCRLPRG, "pcrl"},
 261         {JPC_COD_CPRLPRG, "cprl"},
 262         {-1, 0}
 263 };
 264
 265 typedef enum {
 266         MODE_INT,
 267         MODE_REAL
 268 } modeid_t;
 269
 270 jas_taginfo_t modetab[] = {
 271         {MODE_INT, "int"},
 272         {MODE_REAL, "real"},
 273         {-1, 0}
 274 };
 275
 276 /******************************************************************************\
 277 * The main encoder entry point.
 278 \******************************************************************************/
 279
 280 int jpc_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
 281 {
 282         jpc_enc_t *enc;
 283         jpc_enc_cp_t *cp;
 284
 285         enc = 0;
 286         cp = 0;
 287
 288         jpc_initluts();
 289
 290         if (!(cp = cp_create(optstr, image))) {
 291                 jas_eprintf("invalid JP encoder options\n");
 292                 goto error;
 293         }
 294
 295         if (!(enc = jpc_enc_create(cp, out, image))) {
 296                 goto error;
 297         }
 298         cp = 0;
 299
 300         /* Encode the main header. */
 301         if (jpc_enc_encodemainhdr(enc)) {
 302                 goto error;
 303         }
 304
 305         /* Encode the main body.  This constitutes most of the encoding work. */
 306         if (jpc_enc_encodemainbody(enc)) {
 307                 goto error;
 308         }
 309
 310         /* Write EOC marker segment. */
 311         if (!(enc->mrk = jpc_ms_create(JPC_MS_EOC))) {
 312                 goto error;
 313         }
 314         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
 315                 jas_eprintf("cannot write EOI marker\n");
 316                 goto error;
 317         }
 318         jpc_ms_destroy(enc->mrk);
 319         enc->mrk = 0;
 320
 321         if (jas_stream_flush(enc->out)) {
 322                 goto error;
 323         }
 324
 325         jpc_enc_destroy(enc);
 326
 327         return 0;
 328
 329 error:
 330         if (cp) {
 331                 jpc_enc_cp_destroy(cp);
 332         }
 333         if (enc) {
 334                 jpc_enc_destroy(enc);
 335         }
 336         return -1;
 337 }
 338
 339 /******************************************************************************\
 340 * Option parsing code.
 341 \******************************************************************************/
 342
 343 static jpc_enc_cp_t *cp_create(char *optstr, jas_image_t *image)
 344 {
 345         jpc_enc_cp_t *cp;
 346         jas_tvparser_t *tvp;
 347         int ret;
 348         int numilyrrates;
 349         double *ilyrrates;
 350         int i;
 351         int tagid;
 352         jpc_enc_tcp_t *tcp;
 353         jpc_enc_tccp_t *tccp;
 354         jpc_enc_ccp_t *ccp;
 355         int cmptno;
 356         uint_fast16_t rlvlno;
 357         uint_fast16_t prcwidthexpn;
 358         uint_fast16_t prcheightexpn;
 359         bool enablemct;
 360         uint_fast32_t jp2overhead;
 361         uint_fast16_t lyrno;
 362         uint_fast32_t hsteplcm;
 363         uint_fast32_t vsteplcm;
 364         bool mctvalid;
 365
 366         tvp = 0;
 367         cp = 0;
 368         ilyrrates = 0;
 369         numilyrrates = 0;
 370
 371         if (!(cp = jas_malloc(sizeof(jpc_enc_cp_t)))) {
 372                 goto error;
 373         }
 374
 375         prcwidthexpn = 15;
 376         prcheightexpn = 15;
 377         enablemct = true;
 378         jp2overhead = 0;
 379
 380         cp->ccps = 0;
 381         cp->debug = 0;
 382         cp->imgareatlx = UINT_FAST32_MAX;
 383         cp->imgareatly = UINT_FAST32_MAX;
 384         cp->refgrdwidth = 0;
 385         cp->refgrdheight = 0;
 386         cp->tilegrdoffx = UINT_FAST32_MAX;
 387         cp->tilegrdoffy = UINT_FAST32_MAX;
 388         cp->tilewidth = 0;
 389         cp->tileheight = 0;
 390         cp->numcmpts = jas_image_numcmpts(image);
 391
 392         hsteplcm = 1;
 393         vsteplcm = 1;
 394         for (cmptno = 0; cmptno < jas_image_numcmpts(image); ++cmptno) {
 395                 if (jas_image_cmptbrx(image, cmptno) + jas_image_cmpthstep(image, cmptno) <=
 396                   jas_image_brx(image) || jas_image_cmptbry(image, cmptno) +
 397                   jas_image_cmptvstep(image, cmptno) <= jas_image_bry(image)) {
 398                         jas_eprintf("unsupported image type\n");
 399                         goto error;
 400                 }
 401                 /* Note: We ought to be calculating the LCMs here.  Fix some day. */
 402                 hsteplcm *= jas_image_cmpthstep(image, cmptno);
 403                 vsteplcm *= jas_image_cmptvstep(image, cmptno);
 404         }
 405
 406         if (!(cp->ccps = jas_malloc(cp->numcmpts * sizeof(jpc_enc_ccp_t)))) {
 407                 goto error;
 408         }
 409         for (cmptno = 0, ccp = cp->ccps; cmptno < JAS_CAST(int, cp->numcmpts); ++cmptno,
 410           ++ccp) {
 411                 ccp->sampgrdstepx = jas_image_cmpthstep(image, cmptno);
 412                 ccp->sampgrdstepy = jas_image_cmptvstep(image, cmptno);
 413                 /* XXX - this isn't quite correct for more general image */
 414                 ccp->sampgrdsubstepx = 0;
 415                 ccp->sampgrdsubstepx = 0;
 416                 ccp->prec = jas_image_cmptprec(image, cmptno);
 417                 ccp->sgnd = jas_image_cmptsgnd(image, cmptno);
 418                 ccp->numstepsizes = 0;
 419                 memset(ccp->stepsizes, 0, sizeof(ccp->stepsizes));
 420         }
 421
 422         cp->rawsize = jas_image_rawsize(image);
 423         cp->totalsize = UINT_FAST32_MAX;
 424
 425         tcp = &cp->tcp;
 426         tcp->csty = 0;
 427         tcp->intmode = true;
 428         tcp->prg = JPC_COD_LRCPPRG;
 429         tcp->numlyrs = 1;
 430         tcp->ilyrrates = 0;
 431
 432         tccp = &cp->tccp;
 433         tccp->csty = 0;
 434         tccp->maxrlvls = 6;
 435         tccp->cblkwidthexpn = 6;
 436         tccp->cblkheightexpn = 6;
 437         tccp->cblksty = 0;
 438         tccp->numgbits = 2;
 439
 440         if (!(tvp = jas_tvparser_create(optstr ? optstr : ""))) {
 441                 goto error;
 442         }
 443
 444         while (!(ret = jas_tvparser_next(tvp))) {
 445                 switch (jas_taginfo_nonull(jas_taginfos_lookup(encopts,
 446                   jas_tvparser_gettag(tvp)))->id) {
 447                 case OPT_DEBUG:
 448                         cp->debug = atoi(jas_tvparser_getval(tvp));
 449                         break;
 450                 case OPT_IMGAREAOFFX:
 451                         cp->imgareatlx = atoi(jas_tvparser_getval(tvp));
 452                         break;
 453                 case OPT_IMGAREAOFFY:
 454                         cp->imgareatly = atoi(jas_tvparser_getval(tvp));
 455                         break;
 456                 case OPT_TILEGRDOFFX:
 457                         cp->tilegrdoffx = atoi(jas_tvparser_getval(tvp));
 458                         break;
 459                 case OPT_TILEGRDOFFY:
 460                         cp->tilegrdoffy = atoi(jas_tvparser_getval(tvp));
 461                         break;
 462                 case OPT_TILEWIDTH:
 463                         cp->tilewidth = atoi(jas_tvparser_getval(tvp));
 464                         break;
 465                 case OPT_TILEHEIGHT:
 466                         cp->tileheight = atoi(jas_tvparser_getval(tvp));
 467                         break;
 468                 case OPT_PRCWIDTH:
 469                         prcwidthexpn = jpc_floorlog2(atoi(jas_tvparser_getval(tvp)));
 470                         break;
 471                 case OPT_PRCHEIGHT:
 472                         prcheightexpn = jpc_floorlog2(atoi(jas_tvparser_getval(tvp)));
 473                         break;
 474                 case OPT_CBLKWIDTH:
 475                         tccp->cblkwidthexpn =
 476                           jpc_floorlog2(atoi(jas_tvparser_getval(tvp)));
 477                         break;
 478                 case OPT_CBLKHEIGHT:
 479                         tccp->cblkheightexpn =
 480                           jpc_floorlog2(atoi(jas_tvparser_getval(tvp)));
 481                         break;
 482                 case OPT_MODE:
 483                         if ((tagid = jas_taginfo_nonull(jas_taginfos_lookup(modetab,
 484                           jas_tvparser_getval(tvp)))->id) < 0) {
 485                                 jas_eprintf("ignoring invalid mode %s\n",
 486                                   jas_tvparser_getval(tvp));
 487                         } else {
 488                                 tcp->intmode = (tagid == MODE_INT);
 489                         }
 490                         break;
 491                 case OPT_PRG:
 492                         if ((tagid = jas_taginfo_nonull(jas_taginfos_lookup(prgordtab,
 493                           jas_tvparser_getval(tvp)))->id) < 0) {
 494                                 jas_eprintf("ignoring invalid progression order %s\n",
 495                                   jas_tvparser_getval(tvp));
 496                         } else {
 497                                 tcp->prg = tagid;
 498                         }
 499                         break;
 500                 case OPT_NOMCT:
 501                         enablemct = false;
 502                         break;
 503                 case OPT_MAXRLVLS:
 504                         tccp->maxrlvls = atoi(jas_tvparser_getval(tvp));
 505                         break;
 506                 case OPT_SOP:
 507                         cp->tcp.csty |= JPC_COD_SOP;
 508                         break;
 509                 case OPT_EPH:
 510                         cp->tcp.csty |= JPC_COD_EPH;
 511                         break;
 512                 case OPT_LAZY:
 513                         tccp->cblksty |= JPC_COX_LAZY;
 514                         break;
 515                 case OPT_TERMALL:
 516                         tccp->cblksty |= JPC_COX_TERMALL;
 517                         break;
 518                 case OPT_SEGSYM:
 519                         tccp->cblksty |= JPC_COX_SEGSYM;
 520                         break;
 521                 case OPT_VCAUSAL:
 522                         tccp->cblksty |= JPC_COX_VSC;
 523                         break;
 524                 case OPT_RESET:
 525                         tccp->cblksty |= JPC_COX_RESET;
 526                         break;
 527                 case OPT_PTERM:
 528                         tccp->cblksty |= JPC_COX_PTERM;
 529                         break;
 530                 case OPT_NUMGBITS:
 531                         cp->tccp.numgbits = atoi(jas_tvparser_getval(tvp));
 532                         break;
 533                 case OPT_RATE:
 534                         if (ratestrtosize(jas_tvparser_getval(tvp), cp->rawsize,
 535                           &cp->totalsize)) {
 536                                 jas_eprintf("ignoring bad rate specifier %s\n",
 537                                   jas_tvparser_getval(tvp));
 538                         }
 539                         break;
 540                 case OPT_ILYRRATES:
 541                         if (jpc_atoaf(jas_tvparser_getval(tvp), &numilyrrates,
 542                           &ilyrrates)) {
 543                                 jas_eprintf("warning: invalid intermediate layer rates specifier ignored (%s)\n",
 544                                   jas_tvparser_getval(tvp));
 545                         }
 546                         break;
 547
 548                 case OPT_JP2OVERHEAD:
 549                         jp2overhead = atoi(jas_tvparser_getval(tvp));
 550                         break;
 551                 default:
 552                         jas_eprintf("warning: ignoring invalid option %s\n",
 553                          jas_tvparser_gettag(tvp));
 554                         break;
 555                 }
 556         }
 557
 558         jas_tvparser_destroy(tvp);
 559         tvp = 0;
 560
 561         if (cp->totalsize != UINT_FAST32_MAX) {
 562                 cp->totalsize = (cp->totalsize > jp2overhead) ?
 563                   (cp->totalsize - jp2overhead) : 0;
 564         }
 565
 566         if (cp->imgareatlx == UINT_FAST32_MAX) {
 567                 cp->imgareatlx = 0;
 568         } else {
 569                 if (hsteplcm != 1) {
 570                         jas_eprintf("warning: overriding imgareatlx value\n");
 571                 }
 572                 cp->imgareatlx *= hsteplcm;
 573         }
 574         if (cp->imgareatly == UINT_FAST32_MAX) {
 575                 cp->imgareatly = 0;
 576         } else {
 577                 if (vsteplcm != 1) {
 578                         jas_eprintf("warning: overriding imgareatly value\n");
 579                 }
 580                 cp->imgareatly *= vsteplcm;
 581         }
 582         cp->refgrdwidth = cp->imgareatlx + jas_image_width(image);
 583         cp->refgrdheight = cp->imgareatly + jas_image_height(image);
 584         if (cp->tilegrdoffx == UINT_FAST32_MAX) {
 585                 cp->tilegrdoffx = cp->imgareatlx;
 586         }
 587         if (cp->tilegrdoffy == UINT_FAST32_MAX) {
 588                 cp->tilegrdoffy = cp->imgareatly;
 589         }
 590         if (!cp->tilewidth) {
 591                 cp->tilewidth = cp->refgrdwidth - cp->tilegrdoffx;
 592         }
 593         if (!cp->tileheight) {
 594                 cp->tileheight = cp->refgrdheight - cp->tilegrdoffy;
 595         }
 596
 597         if (cp->numcmpts == 3) {
 598                 mctvalid = true;
 599                 for (cmptno = 0; cmptno < jas_image_numcmpts(image); ++cmptno) {
 600                         if (jas_image_cmptprec(image, cmptno) != jas_image_cmptprec(image, 0) ||
 601                           jas_image_cmptsgnd(image, cmptno) != jas_image_cmptsgnd(image, 0) ||
 602                           jas_image_cmptwidth(image, cmptno) != jas_image_cmptwidth(image, 0) ||
 603                           jas_image_cmptheight(image, cmptno) != jas_image_cmptheight(image, 0)) {
 604                                 mctvalid = false;
 605                         }
 606                 }
 607         } else {
 608                 mctvalid = false;
 609         }
 610         if (mctvalid && enablemct && jas_clrspc_fam(jas_image_clrspc(image)) != JAS_CLRSPC_FAM_RGB) {
 611                 jas_eprintf("warning: color space apparently not RGB\n");
 612         }
 613         if (mctvalid && enablemct && jas_clrspc_fam(jas_image_clrspc(image)) == JAS_CLRSPC_FAM_RGB) {
 614                 tcp->mctid = (tcp->intmode) ? (JPC_MCT_RCT) : (JPC_MCT_ICT);
 615         } else {
 616                 tcp->mctid = JPC_MCT_NONE;
 617         }
 618         tccp->qmfbid = (tcp->intmode) ? (JPC_COX_RFT) : (JPC_COX_INS);
 619
 620         for (rlvlno = 0; rlvlno < tccp->maxrlvls; ++rlvlno) {
 621                 tccp->prcwidthexpns[rlvlno] = prcwidthexpn;
 622                 tccp->prcheightexpns[rlvlno] = prcheightexpn;
 623         }
 624         if (prcwidthexpn != 15 || prcheightexpn != 15) {
 625                 tccp->csty |= JPC_COX_PRT;
 626         }
 627
 628         /* Ensure that the tile width and height is valid. */
 629         if (!cp->tilewidth) {
 630                 jas_eprintf("invalid tile width %lu\n", (unsigned long)
 631                   cp->tilewidth);
 632                 goto error;
 633         }
 634         if (!cp->tileheight) {
 635                 jas_eprintf("invalid tile height %lu\n", (unsigned long)
 636                   cp->tileheight);
 637                 goto error;
 638         }
 639
 640         /* Ensure that the tile grid offset is valid. */
 641         if (cp->tilegrdoffx > cp->imgareatlx ||
 642           cp->tilegrdoffy > cp->imgareatly ||
 643           cp->tilegrdoffx + cp->tilewidth < cp->imgareatlx ||
 644           cp->tilegrdoffy + cp->tileheight < cp->imgareatly) {
 645                 jas_eprintf("invalid tile grid offset (%lu, %lu)\n",
 646                   (unsigned long) cp->tilegrdoffx, (unsigned long)
 647                   cp->tilegrdoffy);
 648                 goto error;
 649         }
 650
 651         cp->numhtiles = JPC_CEILDIV(cp->refgrdwidth - cp->tilegrdoffx,
 652           cp->tilewidth);
 653         cp->numvtiles = JPC_CEILDIV(cp->refgrdheight - cp->tilegrdoffy,
 654           cp->tileheight);
 655         cp->numtiles = cp->numhtiles * cp->numvtiles;
 656
 657         if (ilyrrates && numilyrrates > 0) {
 658                 tcp->numlyrs = numilyrrates + 1;
 659                 if (!(tcp->ilyrrates = jas_malloc((tcp->numlyrs - 1) *
 660                   sizeof(jpc_fix_t)))) {
 661                         goto error;
 662                 }
 663                 for (i = 0; i < JAS_CAST(int, tcp->numlyrs - 1); ++i) {
 664                         tcp->ilyrrates[i] = jpc_dbltofix(ilyrrates[i]);
 665                 }
 666         }
 667
 668         /* Ensure that the integer mode is used in the case of lossless
 669           coding. */
 670         if (cp->totalsize == UINT_FAST32_MAX && (!cp->tcp.intmode)) {
 671                 jas_eprintf("cannot use real mode for lossless coding\n");
 672                 goto error;
 673         }
 674
 675         /* Ensure that the precinct width is valid. */
 676         if (prcwidthexpn > 15) {
 677                 jas_eprintf("invalid precinct width\n");
 678                 goto error;
 679         }
 680
 681         /* Ensure that the precinct height is valid. */
 682         if (prcheightexpn > 15) {
 683                 jas_eprintf("invalid precinct height\n");
 684                 goto error;
 685         }
 686
 687         /* Ensure that the code block width is valid. */
 688         if (cp->tccp.cblkwidthexpn < 2 || cp->tccp.cblkwidthexpn > 12) {
 689                 jas_eprintf("invalid code block width %d\n",
 690                   JPC_POW2(cp->tccp.cblkwidthexpn));
 691                 goto error;
 692         }
 693
 694         /* Ensure that the code block height is valid. */
 695         if (cp->tccp.cblkheightexpn < 2 || cp->tccp.cblkheightexpn > 12) {
 696                 jas_eprintf("invalid code block height %d\n",
 697                   JPC_POW2(cp->tccp.cblkheightexpn));
 698                 goto error;
 699         }
 700
 701         /* Ensure that the code block size is not too large. */
 702         if (cp->tccp.cblkwidthexpn + cp->tccp.cblkheightexpn > 12) {
 703                 jas_eprintf("code block size too large\n");
 704                 goto error;
 705         }
 706
 707         /* Ensure that the number of layers is valid. */
 708         if (cp->tcp.numlyrs > 16384) {
 709                 jas_eprintf("too many layers\n");
 710                 goto error;
 711         }
 712
 713         /* There must be at least one resolution level. */
 714         if (cp->tccp.maxrlvls < 1) {
 715                 jas_eprintf("must be at least one resolution level\n");
 716                 goto error;
 717         }
 718
 719         /* Ensure that the number of guard bits is valid. */
 720         if (cp->tccp.numgbits > 8) {
 721                 jas_eprintf("invalid number of guard bits\n");
 722                 goto error;
 723         }
 724
 725         /* Ensure that the rate is within the legal range. */
 726         if (cp->totalsize != UINT_FAST32_MAX && cp->totalsize > cp->rawsize) {
 727                 jas_eprintf("warning: specified rate is unreasonably large (%lu > %lu)\n", (unsigned long) cp->totalsize, (unsigned long) cp->rawsize);
 728         }
 729
 730         /* Ensure that the intermediate layer rates are valid. */
 731         if (tcp->numlyrs > 1) {
 732                 /* The intermediate layers rates must increase monotonically. */
 733                 for (lyrno = 0; lyrno + 2 < tcp->numlyrs; ++lyrno) {
 734                         if (tcp->ilyrrates[lyrno] >= tcp->ilyrrates[lyrno + 1]) {
 735                                 jas_eprintf("intermediate layer rates must increase monotonically\n");
 736                                 goto error;
 737                         }
 738                 }
 739                 /* The intermediate layer rates must be less than the overall rate. */
 740                 if (cp->totalsize != UINT_FAST32_MAX) {
 741                         for (lyrno = 0; lyrno < tcp->numlyrs - 1; ++lyrno) {
 742                                 if (jpc_fixtodbl(tcp->ilyrrates[lyrno]) > ((double) cp->totalsize)
 743                                   / cp->rawsize) {
 744                                         jas_eprintf("warning: intermediate layer rates must be less than overall rate\n");
 745                                         goto error;
 746                                 }
 747                         }
 748                 }
 749         }
 750
 751         if (ilyrrates) {
 752                 jas_free(ilyrrates);
 753         }
 754
 755         return cp;
 756
 757 error:
 758
 759         if (ilyrrates) {
 760                 jas_free(ilyrrates);
 761         }
 762         if (tvp) {
 763                 jas_tvparser_destroy(tvp);
 764         }
 765         if (cp) {
 766                 jpc_enc_cp_destroy(cp);
 767         }
 768         return 0;
 769 }
 770
 771 void jpc_enc_cp_destroy(jpc_enc_cp_t *cp)
 772 {
 773         if (cp->ccps) {
 774                 if (cp->tcp.ilyrrates) {
 775                         jas_free(cp->tcp.ilyrrates);
 776                 }
 777                 jas_free(cp->ccps);
 778         }
 779         jas_free(cp);
 780 }
 781
 782 int ratestrtosize(char *s, uint_fast32_t rawsize, uint_fast32_t *size)
 783 {
 784         char *cp;
 785         jpc_flt_t f;
 786
 787         /* Note: This function must not modify output size on failure. */
 788         if ((cp = strchr(s, 'B'))) {
 789                 *size = atoi(s);
 790         } else {
 791                 f = atof(s);
 792                 if (f < 0) {
 793                         *size = 0;
 794                 } else if (f > 1.0) {
 795                         *size = rawsize + 1;
 796                 } else {
 797                         *size = f * rawsize;
 798                 }
 799         }
 800         return 0;
 801 }
 802
 803 /******************************************************************************\
 804 * Encoder constructor and destructor.
 805 \******************************************************************************/
 806
 807 jpc_enc_t *jpc_enc_create(jpc_enc_cp_t *cp, jas_stream_t *out, jas_image_t *image)
 808 {
 809         jpc_enc_t *enc;
 810
 811         enc = 0;
 812
 813         if (!(enc = jas_malloc(sizeof(jpc_enc_t)))) {
 814                 goto error;
 815         }
 816
 817         enc->image = image;
 818         enc->out = out;
 819         enc->cp = cp;
 820         enc->cstate = 0;
 821         enc->tmpstream = 0;
 822         enc->mrk = 0;
 823         enc->curtile = 0;
 824
 825         if (!(enc->cstate = jpc_cstate_create())) {
 826                 goto error;
 827         }
 828         enc->len = 0;
 829         enc->mainbodysize = 0;
 830
 831         return enc;
 832
 833 error:
 834
 835         if (enc) {
 836                 jpc_enc_destroy(enc);
 837         }
 838         return 0;
 839 }
 840
 841 void jpc_enc_destroy(jpc_enc_t *enc)
 842 {
 843         /* The image object (i.e., enc->image) and output stream object
 844         (i.e., enc->out) are created outside of the encoder.
 845         Therefore, they must not be destroyed here. */
 846
 847         if (enc->curtile) {
 848                 jpc_enc_tile_destroy(enc->curtile);
 849         }
 850         if (enc->cp) {
 851                 jpc_enc_cp_destroy(enc->cp);
 852         }
 853         if (enc->cstate) {
 854                 jpc_cstate_destroy(enc->cstate);
 855         }
 856         if (enc->tmpstream) {
 857                 jas_stream_close(enc->tmpstream);
 858         }
 859
 860         jas_free(enc);
 861 }
 862
 863 /******************************************************************************\
 864 * Code.
 865 \******************************************************************************/
 866
 867 static int jpc_calcssmant(jpc_fix_t stepsize)
 868 {
 869         int n;
 870         int e;
 871         int m;
 872
 873         n = jpc_firstone(stepsize);
 874         e = n - JPC_FIX_FRACBITS;
 875         if (n >= 11) {
 876                 m = (stepsize >> (n - 11)) & 0x7ff;
 877         } else {
 878                 m = (stepsize & ((1 << n) - 1)) << (11 - n);
 879         }
 880         return m;
 881 }
 882
 883 static int jpc_calcssexp(jpc_fix_t stepsize)
 884 {
 885         return jpc_firstone(stepsize) - JPC_FIX_FRACBITS;
 886 }
 887
 888 static int jpc_enc_encodemainhdr(jpc_enc_t *enc)
 889 {
 890         jpc_siz_t *siz;
 891         jpc_cod_t *cod;
 892         jpc_qcd_t *qcd;
 893         int i;
 894 long startoff;
 895 long mainhdrlen;
 896         jpc_enc_cp_t *cp;
 897         jpc_qcc_t *qcc;
 898         jpc_enc_tccp_t *tccp;
 899         uint_fast16_t cmptno;
 900         jpc_tsfb_band_t bandinfos[JPC_MAXBANDS];
 901         jpc_fix_t mctsynweight;
 902         jpc_enc_tcp_t *tcp;
 903         jpc_tsfb_t *tsfb;
 904         jpc_tsfb_band_t *bandinfo;
 905         uint_fast16_t numbands;
 906         uint_fast16_t bandno;
 907         uint_fast16_t rlvlno;
 908         uint_fast16_t analgain;
 909         jpc_fix_t absstepsize;
 910         char buf[1024];
 911         jpc_com_t *com;
 912
 913         cp = enc->cp;
 914
 915 startoff = jas_stream_getrwcount(enc->out);
 916
 917         /* Write SOC marker segment. */
 918         if (!(enc->mrk = jpc_ms_create(JPC_MS_SOC))) {
 919                 return -1;
 920         }
 921         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
 922                 jas_eprintf("cannot write SOC marker\n");
 923                 return -1;
 924         }
 925         jpc_ms_destroy(enc->mrk);
 926         enc->mrk = 0;
 927
 928         /* Write SIZ marker segment. */
 929         if (!(enc->mrk = jpc_ms_create(JPC_MS_SIZ))) {
 930                 return -1;
 931         }
 932         siz = &enc->mrk->parms.siz;
 933         siz->caps = 0;
 934         siz->xoff = cp->imgareatlx;
 935         siz->yoff = cp->imgareatly;
 936         siz->width = cp->refgrdwidth;
 937         siz->height = cp->refgrdheight;
 938         siz->tilexoff = cp->tilegrdoffx;
 939         siz->tileyoff = cp->tilegrdoffy;
 940         siz->tilewidth = cp->tilewidth;
 941         siz->tileheight = cp->tileheight;
 942         siz->numcomps = cp->numcmpts;
 943         siz->comps = jas_malloc(siz->numcomps * sizeof(jpc_sizcomp_t));
 944         assert(siz->comps);
 945         for (i = 0; i < JAS_CAST(int, cp->numcmpts); ++i) {
 946                 siz->comps[i].prec = cp->ccps[i].prec;
 947                 siz->comps[i].sgnd = cp->ccps[i].sgnd;
 948                 siz->comps[i].hsamp = cp->ccps[i].sampgrdstepx;
 949                 siz->comps[i].vsamp = cp->ccps[i].sampgrdstepy;
 950         }
 951         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
 952                 jas_eprintf("cannot write SIZ marker\n");
 953                 return -1;
 954         }
 955         jpc_ms_destroy(enc->mrk);
 956         enc->mrk = 0;
 957
 958         if (!(enc->mrk = jpc_ms_create(JPC_MS_COM))) {
 959                 return -1;
 960         }
 961         sprintf(buf, "Creator: JasPer Version %s", jas_getversion());
 962         com = &enc->mrk->parms.com;
 963         com->len = strlen(buf);
 964         com->regid = JPC_COM_LATIN;
 965         if (!(com->data = JAS_CAST(uchar *, jas_strdup(buf)))) {
 966                 abort();
 967         }
 968         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
 969                 jas_eprintf("cannot write COM marker\n");
 970                 return -1;
 971         }
 972         jpc_ms_destroy(enc->mrk);
 973         enc->mrk = 0;
 974
 975 #if 0
 976         if (!(enc->mrk = jpc_ms_create(JPC_MS_CRG))) {
 977                 return -1;
 978         }
 979         crg = &enc->mrk->parms.crg;
 980         crg->comps = jas_malloc(crg->numcomps * sizeof(jpc_crgcomp_t));
 981         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
 982                 jas_eprintf("cannot write CRG marker\n");
 983                 return -1;
 984         }
 985         jpc_ms_destroy(enc->mrk);
 986         enc->mrk = 0;
 987 #endif
 988
 989         tcp = &cp->tcp;
 990         tccp = &cp->tccp;
 991         for (cmptno = 0; cmptno < cp->numcmpts; ++cmptno) {
 992                 tsfb = jpc_cod_gettsfb(tccp->qmfbid, tccp->maxrlvls - 1);
 993                 jpc_tsfb_getbands(tsfb, 0, 0, 1 << tccp->maxrlvls, 1 << tccp->maxrlvls,
 994                   bandinfos);
 995                 jpc_tsfb_destroy(tsfb);
 996                 mctsynweight = jpc_mct_getsynweight(tcp->mctid, cmptno);
 997                 numbands = 3 * tccp->maxrlvls - 2;
 998                 for (bandno = 0, bandinfo = bandinfos; bandno < numbands;
 999                   ++bandno, ++bandinfo) {
1000                         rlvlno = (bandno) ? ((bandno - 1) / 3 + 1) : 0;
1001                         analgain = JPC_NOMINALGAIN(tccp->qmfbid, tccp->maxrlvls,
1002                           rlvlno, bandinfo->orient);
1003                         if (!tcp->intmode) {
1004                                 absstepsize = jpc_fix_div(jpc_inttofix(1 <<
1005                                   (analgain + 1)), bandinfo->synenergywt);
1006                         } else {
1007                                 absstepsize = jpc_inttofix(1);
1008                         }
1009                         cp->ccps[cmptno].stepsizes[bandno] =
1010                           jpc_abstorelstepsize(absstepsize,
1011                           cp->ccps[cmptno].prec + analgain);
1012                 }
1013                 cp->ccps[cmptno].numstepsizes = numbands;
1014         }
1015
1016         if (!(enc->mrk = jpc_ms_create(JPC_MS_COD))) {
1017                 return -1;
1018         }
1019         cod = &enc->mrk->parms.cod;
1020         cod->csty = cp->tccp.csty | cp->tcp.csty;
1021         cod->compparms.csty = cp->tccp.csty | cp->tcp.csty;
1022         cod->compparms.numdlvls = cp->tccp.maxrlvls - 1;
1023         cod->compparms.numrlvls = cp->tccp.maxrlvls;
1024         cod->prg = cp->tcp.prg;
1025         cod->numlyrs = cp->tcp.numlyrs;
1026         cod->compparms.cblkwidthval = JPC_COX_CBLKSIZEEXPN(cp->tccp.cblkwidthexpn);
1027         cod->compparms.cblkheightval = JPC_COX_CBLKSIZEEXPN(cp->tccp.cblkheightexpn);
1028         cod->compparms.cblksty = cp->tccp.cblksty;
1029         cod->compparms.qmfbid = cp->tccp.qmfbid;
1030         cod->mctrans = (cp->tcp.mctid != JPC_MCT_NONE);
1031         if (tccp->csty & JPC_COX_PRT) {
1032                 for (rlvlno = 0; rlvlno < tccp->maxrlvls; ++rlvlno) {
1033                         cod->compparms.rlvls[rlvlno].parwidthval = tccp->prcwidthexpns[rlvlno];
1034                         cod->compparms.rlvls[rlvlno].parheightval = tccp->prcheightexpns[rlvlno];
1035                 }
1036         }
1037         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
1038                 jas_eprintf("cannot write COD marker\n");
1039                 return -1;
1040         }
1041         jpc_ms_destroy(enc->mrk);
1042         enc->mrk = 0;
1043
1044         if (!(enc->mrk = jpc_ms_create(JPC_MS_QCD))) {
1045                 return -1;
1046         }
1047         qcd = &enc->mrk->parms.qcd;
1048         qcd->compparms.qntsty = (tccp->qmfbid == JPC_COX_INS) ?
1049           JPC_QCX_SEQNT : JPC_QCX_NOQNT;
1050         qcd->compparms.numstepsizes = cp->ccps[0].numstepsizes;
1051         qcd->compparms.numguard = cp->tccp.numgbits;
1052         qcd->compparms.stepsizes = cp->ccps[0].stepsizes;
1053         if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
1054                 return -1;
1055         }
1056         /* We do not want the step size array to be freed! */
1057         qcd->compparms.stepsizes = 0;
1058         jpc_ms_destroy(enc->mrk);
1059         enc->mrk = 0;
1060
1061         tccp = &cp->tccp;
1062         for (cmptno = 1; cmptno < cp->numcmpts; ++cmptno) {
1063                 if (!(enc->mrk = jpc_ms_create(JPC_MS_QCC))) {
1064                         return -1;
1065                 }
1066                 qcc = &enc->mrk->parms.qcc;
1067                 qcc->compno = cmptno;
1068                 qcc->compparms.qntsty = (tccp->qmfbid == JPC_COX_INS) ?
1069                   JPC_QCX_SEQNT : JPC_QCX_NOQNT;
1070                 qcc->compparms.numstepsizes = cp->ccps[cmptno].numstepsizes;
1071                 qcc->compparms.numguard = cp->tccp.numgbits;
1072                 qcc->compparms.stepsizes = cp->ccps[cmptno].stepsizes;
1073                 if (jpc_putms(enc->out, enc->cstate, enc->mrk)) {
1074                         return -1;
1075                 }
1076                 /* We do not want the step size array to be freed! */
1077                 qcc->compparms.stepsizes = 0;
1078                 jpc_ms_destroy(enc->mrk);
1079                 enc->mrk = 0;
1080         }
1081
1082 #define MAINTLRLEN      2
1083         mainhdrlen = jas_stream_getrwcount(enc->out) - startoff;
1084         enc->len += mainhdrlen;
1085         if (enc->cp->totalsize != UINT_FAST32_MAX) {
1086                 uint_fast32_t overhead;
1087                 overhead = mainhdrlen + MAINTLRLEN;
1088                 enc->mainbodysize = (enc->cp->totalsize >= overhead) ?
1089                   (enc->cp->totalsize - overhead) : 0;
1090         } else {
1091                 enc->mainbodysize = UINT_FAST32_MAX;
1092         }
1093
1094         return 0;
1095 }
1096
1097 static int jpc_enc_encodemainbody(jpc_enc_t *enc)
1098 {
1099         int tileno;
1100         int tilex;
1101         int tiley;
1102         int i;
1103         jpc_sot_t *sot;
1104         jpc_enc_tcmpt_t *comp;
1105         jpc_enc_tcmpt_t *endcomps;
1106         jpc_enc_band_t *band;
1107         jpc_enc_band_t *endbands;
1108         jpc_enc_rlvl_t *lvl;
1109         int rlvlno;
1110         jpc_qcc_t *qcc;
1111         jpc_cod_t *cod;
1112         int adjust;
1113         int j;
1114         int absbandno;
1115         long numbytes;
1116         long tilehdrlen;
1117         long tilelen;
1118         jpc_enc_tile_t *tile;
1119         jpc_enc_cp_t *cp;
1120         double rho;
1121         int lyrno;
1122         int cmptno;
1123         int samestepsizes;
1124         jpc_enc_ccp_t *ccps;
1125         jpc_enc_tccp_t *tccp;
1126 int bandno;
1127 uint_fast32_t x;
1128 uint_fast32_t y;
1129 int mingbits;
1130 int actualnumbps;
1131 jpc_fix_t mxmag;
1132 jpc_fix_t mag;
1133 int numgbits;
1134
1135         cp = enc->cp;
1136
1137         /* Avoid compile warnings. */
1138         numbytes = 0;
1139
1140         for (tileno = 0; tileno < JAS_CAST(int, cp->numtiles); ++tileno) {
1141                 tilex = tileno % cp->numhtiles;
1142                 tiley = tileno / cp->numhtiles;
1143
1144                 if (!(enc->curtile = jpc_enc_tile_create(enc->cp, enc->image, tileno))) {
1145                         abort();
1146                 }
1147
1148                 tile = enc->curtile;
1149
1150                 if (jas_getdbglevel() >= 10) {
1151                         jpc_enc_dump(enc);
1152                 }
1153
1154                 endcomps = &tile->tcmpts[tile->numtcmpts];
1155                 for (cmptno = 0, comp = tile->tcmpts; cmptno < tile->numtcmpts; ++cmptno, ++comp) {
1156                         if (!cp->ccps[cmptno].sgnd) {
1157                                 adjust = 1 << (cp->ccps[cmptno].prec - 1);
1158                                 for (i = 0; i < jas_matrix_numrows(comp->data); ++i) {
1159                                         for (j = 0; j < jas_matrix_numcols(comp->data); ++j) {
1160                                                 *jas_matrix_getref(comp->data, i, j) -= adjust;
1161                                         }
1162                                 }
1163                         }
1164                 }
1165
1166                 if (!tile->intmode) {
1167                                 endcomps = &tile->tcmpts[tile->numtcmpts];
1168                                 for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1169                                         jas_matrix_asl(comp->data, JPC_FIX_FRACBITS);
1170                                 }
1171                 }
1172
1173                 switch (tile->mctid) {
1174                 case JPC_MCT_RCT:
1175 assert(jas_image_numcmpts(enc->image) == 3);
1176                         jpc_rct(tile->tcmpts[0].data, tile->tcmpts[1].data,
1177                           tile->tcmpts[2].data);
1178                         break;
1179                 case JPC_MCT_ICT:
1180 assert(jas_image_numcmpts(enc->image) == 3);
1181                         jpc_ict(tile->tcmpts[0].data, tile->tcmpts[1].data,
1182                           tile->tcmpts[2].data);
1183                         break;
1184                 default:
1185                         break;
1186                 }
1187
1188                 for (i = 0; i < jas_image_numcmpts(enc->image); ++i) {
1189                         comp = &tile->tcmpts[i];
1190                         jpc_tsfb_analyze(comp->tsfb, comp->data);
1191
1192                 }
1193
1194
1195                 endcomps = &tile->tcmpts[tile->numtcmpts];
1196                 for (cmptno = 0, comp = tile->tcmpts; comp != endcomps; ++cmptno, ++comp) {
1197                         mingbits = 0;
1198                         absbandno = 0;
1199                         /* All bands must have a corresponding quantizer step size,
1200                           even if they contain no samples and are never coded. */
1201                         /* Some bands may not be hit by the loop below, so we must
1202                           initialize all of the step sizes to a sane value. */
1203                         memset(comp->stepsizes, 0, sizeof(comp->stepsizes));
1204                         for (rlvlno = 0, lvl = comp->rlvls; rlvlno < comp->numrlvls; ++rlvlno, ++lvl) {
1205                                 if (!lvl->bands) {
1206                                         absbandno += rlvlno ? 3 : 1;
1207                                         continue;
1208                                 }
1209                                 endbands = &lvl->bands[lvl->numbands];
1210                                 for (band = lvl->bands; band != endbands; ++band) {
1211                                         if (!band->data) {
1212                                                 ++absbandno;
1213                                                 continue;
1214                                         }
1215                                         actualnumbps = 0;
1216                                         mxmag = 0;
1217                                         for (y = 0; y < JAS_CAST(uint_fast32_t, jas_matrix_numrows(band->data)); ++y) {
1218                                                 for (x = 0; x < JAS_CAST(uint_fast32_t, jas_matrix_numcols(band->data)); ++x) {
1219                                                         mag = abs(jas_matrix_get(band->data, y, x));
1220                                                         if (mag > mxmag) {
1221                                                                 mxmag = mag;
1222                                                         }
1223                                                 }
1224                                         }
1225                                         if (tile->intmode) {
1226                                                 actualnumbps = jpc_firstone(mxmag) + 1;
1227                                         } else {
1228                                                 actualnumbps = jpc_firstone(mxmag) + 1 - JPC_FIX_FRACBITS;
1229                                         }
1230                                         numgbits = actualnumbps - (cp->ccps[cmptno].prec - 1 +
1231                                           band->analgain);
1232 #if 0
1233 jas_eprintf("%d %d mag=%d actual=%d numgbits=%d\n", cp->ccps[cmptno].prec, band->analgain, mxmag, actualnumbps, numgbits);
1234 #endif
1235                                         if (numgbits > mingbits) {
1236                                                 mingbits = numgbits;
1237                                         }
1238                                         if (!tile->intmode) {
1239                                                 band->absstepsize = jpc_fix_div(jpc_inttofix(1
1240                                                   << (band->analgain + 1)),
1241                                                   band->synweight);
1242                                         } else {
1243                                                 band->absstepsize = jpc_inttofix(1);
1244                                         }
1245                                         band->stepsize = jpc_abstorelstepsize(
1246                                           band->absstepsize, cp->ccps[cmptno].prec +
1247                                           band->analgain);
1248                                         band->numbps = cp->tccp.numgbits +
1249                                           JPC_QCX_GETEXPN(band->stepsize) - 1;
1250
1251                                         if ((!tile->intmode) && band->data) {
1252                                                 jpc_quantize(band->data, band->absstepsize);
1253                                         }
1254
1255                                         comp->stepsizes[absbandno] = band->stepsize;
1256                                         ++absbandno;
1257                                 }
1258                         }
1259
1260                         assert(JPC_FIX_FRACBITS >= JPC_NUMEXTRABITS);
1261                         if (!tile->intmode) {
1262                                 jas_matrix_divpow2(comp->data, JPC_FIX_FRACBITS - JPC_NUMEXTRABITS);
1263                         } else {
1264                                 jas_matrix_asl(comp->data, JPC_NUMEXTRABITS);
1265                         }
1266
1267 #if 0
1268 jas_eprintf("mingbits %d\n", mingbits);
1269 #endif
1270                         if (mingbits > cp->tccp.numgbits) {
1271                                 jas_eprintf("error: too few guard bits (need at least %d)\n",
1272                                   mingbits);
1273                                 return -1;
1274                         }
1275                 }
1276
1277                 if (!(enc->tmpstream = jas_stream_memopen(0, 0))) {
1278                         jas_eprintf("cannot open tmp file\n");
1279                         return -1;
1280                 }
1281
1282                 /* Write the tile header. */
1283                 if (!(enc->mrk = jpc_ms_create(JPC_MS_SOT))) {
1284                         return -1;
1285                 }
1286                 sot = &enc->mrk->parms.sot;
1287                 sot->len = 0;
1288                 sot->tileno = tileno;
1289                 sot->partno = 0;
1290                 sot->numparts = 1;
1291                 if (jpc_putms(enc->tmpstream, enc->cstate, enc->mrk)) {
1292                         jas_eprintf("cannot write SOT marker\n");
1293                         return -1;
1294                 }
1295                 jpc_ms_destroy(enc->mrk);
1296                 enc->mrk = 0;
1297
1298 /************************************************************************/
1299 /************************************************************************/
1300 /************************************************************************/
1301
1302                 tccp = &cp->tccp;
1303                 for (cmptno = 0; cmptno < JAS_CAST(int, cp->numcmpts); ++cmptno) {
1304                         comp = &tile->tcmpts[cmptno];
1305                         if (comp->numrlvls != tccp->maxrlvls) {
1306                                 if (!(enc->mrk = jpc_ms_create(JPC_MS_COD))) {
1307                                         return -1;
1308                                 }
1309 /* XXX = this is not really correct. we are using comp #0's precint sizes
1310 and other characteristics */
1311                                 comp = &tile->tcmpts[0];
1312                                 cod = &enc->mrk->parms.cod;
1313                                 cod->compparms.csty = 0;
1314                                 cod->compparms.numdlvls = comp->numrlvls - 1;
1315                                 cod->prg = tile->prg;
1316                                 cod->numlyrs = tile->numlyrs;
1317                                 cod->compparms.cblkwidthval = JPC_COX_CBLKSIZEEXPN(comp->cblkwidthexpn);
1318                                 cod->compparms.cblkheightval = JPC_COX_CBLKSIZEEXPN(comp->cblkheightexpn);
1319                                 cod->compparms.cblksty = comp->cblksty;
1320                                 cod->compparms.qmfbid = comp->qmfbid;
1321                                 cod->mctrans = (tile->mctid != JPC_MCT_NONE);
1322                                 for (i = 0; i < comp->numrlvls; ++i) {
1323                                         cod->compparms.rlvls[i].parwidthval = comp->rlvls[i].prcwidthexpn;
1324                                         cod->compparms.rlvls[i].parheightval = comp->rlvls[i].prcheightexpn;
1325                                 }
1326                                 if (jpc_putms(enc->tmpstream, enc->cstate, enc->mrk)) {
1327                                         return -1;
1328                                 }
1329                                 jpc_ms_destroy(enc->mrk);
1330                                 enc->mrk = 0;
1331                         }
1332                 }
1333
1334                 for (cmptno = 0, comp = tile->tcmpts; cmptno < JAS_CAST(int, cp->numcmpts); ++cmptno, ++comp) {
1335                         ccps = &cp->ccps[cmptno];
1336                         if (JAS_CAST(int, ccps->numstepsizes) == comp->numstepsizes) {
1337                                 samestepsizes = 1;
1338                                 for (bandno = 0; bandno < JAS_CAST(int, ccps->numstepsizes); ++bandno) {
1339                                         if (ccps->stepsizes[bandno] != comp->stepsizes[bandno]) {
1340                                                 samestepsizes = 0;
1341                                                 break;
1342                                         }
1343                                 }
1344                         } else {
1345                                 samestepsizes = 0;
1346                         }
1347                         if (!samestepsizes) {
1348                                 if (!(enc->mrk = jpc_ms_create(JPC_MS_QCC))) {
1349                                         return -1;
1350                                 }
1351                                 qcc = &enc->mrk->parms.qcc;
1352                                 qcc->compno = cmptno;
1353                                 qcc->compparms.numguard = cp->tccp.numgbits;
1354                                 qcc->compparms.qntsty = (comp->qmfbid == JPC_COX_INS) ?
1355                                   JPC_QCX_SEQNT : JPC_QCX_NOQNT;
1356                                 qcc->compparms.numstepsizes = comp->numstepsizes;
1357                                 qcc->compparms.stepsizes = comp->stepsizes;
1358                                 if (jpc_putms(enc->tmpstream, enc->cstate, enc->mrk)) {
1359                                         return -1;
1360                                 }
1361                                 qcc->compparms.stepsizes = 0;
1362                                 jpc_ms_destroy(enc->mrk);
1363                                 enc->mrk = 0;
1364                         }
1365                 }
1366
1367                 /* Write a SOD marker to indicate the end of the tile header. */
1368                 if (!(enc->mrk = jpc_ms_create(JPC_MS_SOD))) {
1369                         return -1;
1370                 }
1371                 if (jpc_putms(enc->tmpstream, enc->cstate, enc->mrk)) {
1372                         jas_eprintf("cannot write SOD marker\n");
1373                         return -1;
1374                 }
1375                 jpc_ms_destroy(enc->mrk);
1376                 enc->mrk = 0;
1377 tilehdrlen = jas_stream_getrwcount(enc->tmpstream);
1378
1379 /************************************************************************/
1380 /************************************************************************/
1381 /************************************************************************/
1382
1383 if (jpc_enc_enccblks(enc)) {
1384         abort();
1385         return -1;
1386 }
1387
1388                 cp = enc->cp;
1389                 rho = (double) (tile->brx - tile->tlx) * (tile->bry - tile->tly) /
1390                   ((cp->refgrdwidth - cp->imgareatlx) * (cp->refgrdheight -
1391                   cp->imgareatly));
1392                 tile->rawsize = cp->rawsize * rho;
1393
1394                 for (lyrno = 0; lyrno < tile->numlyrs - 1; ++lyrno) {
1395                         tile->lyrsizes[lyrno] = tile->rawsize * jpc_fixtodbl(
1396                           cp->tcp.ilyrrates[lyrno]);
1397                 }
1398                 tile->lyrsizes[tile->numlyrs - 1] = (cp->totalsize != UINT_FAST32_MAX) ?
1399                   (rho * enc->mainbodysize) : UINT_FAST32_MAX;
1400                 for (lyrno = 0; lyrno < tile->numlyrs; ++lyrno) {
1401                         if (tile->lyrsizes[lyrno] != UINT_FAST32_MAX) {
1402                                 if (tilehdrlen <= JAS_CAST(long, tile->lyrsizes[lyrno])) {
1403                                         tile->lyrsizes[lyrno] -= tilehdrlen;
1404                                 } else {
1405                                         tile->lyrsizes[lyrno] = 0;
1406                                 }
1407                         }
1408                 }
1409
1410                 if (rateallocate(enc, tile->numlyrs, tile->lyrsizes)) {
1411                         return -1;
1412                 }
1413
1414 #if 0
1415 jas_eprintf("ENCODE TILE DATA\n");
1416 #endif
1417                 if (jpc_enc_encodetiledata(enc)) {
1418                         jas_eprintf("dotile failed\n");
1419                         return -1;
1420                 }
1421
1422 /************************************************************************/
1423 /************************************************************************/
1424 /************************************************************************/
1425
1426 /************************************************************************/
1427 /************************************************************************/
1428 /************************************************************************/
1429
1430                 tilelen = jas_stream_tell(enc->tmpstream);
1431
1432                 if (jas_stream_seek(enc->tmpstream, 6, SEEK_SET) < 0) {
1433                         return -1;
1434                 }
1435                 jpc_putuint32(enc->tmpstream, tilelen);
1436
1437                 if (jas_stream_seek(enc->tmpstream, 0, SEEK_SET) < 0) {
1438                         return -1;
1439                 }
1440                 if (jpc_putdata(enc->out, enc->tmpstream, -1)) {
1441                         return -1;
1442                 }
1443                 enc->len += tilelen;
1444
1445                 jas_stream_close(enc->tmpstream);
1446                 enc->tmpstream = 0;
1447
1448                 jpc_enc_tile_destroy(enc->curtile);
1449                 enc->curtile = 0;
1450
1451         }
1452
1453         return 0;
1454 }
1455
1456 int jpc_enc_encodetiledata(jpc_enc_t *enc)
1457 {
1458 assert(enc->tmpstream);
1459         if (jpc_enc_encpkts(enc, enc->tmpstream)) {
1460                 return -1;
1461         }
1462         return 0;
1463 }
1464
1465 int dump_passes(jpc_enc_pass_t *passes, int numpasses, jpc_enc_cblk_t *cblk)
1466 {
1467         jpc_enc_pass_t *pass;
1468         int i;
1469         jas_stream_memobj_t *smo;
1470
1471         smo = cblk->stream->obj_;
1472
1473         pass = passes;
1474         for (i = 0; i < numpasses; ++i) {
1475                 jas_eprintf("start=%d end=%d type=%d term=%d lyrno=%d firstchar=%02x size=%ld pos=%ld\n",
1476                   (int)pass->start, (int)pass->end, (int)pass->type, (int)pass->term, (int)pass->lyrno,
1477                   smo->buf_[pass->start], (long)smo->len_, (long)smo->pos_);
1478 #if 0
1479                 jas_memdump(stderr, &smo->buf_[pass->start], pass->end - pass->start);
1480 #endif
1481                 ++pass;
1482         }
1483         return 0;
1484 }
1485
1486 void jpc_quantize(jas_matrix_t *data, jpc_fix_t stepsize)
1487 {
1488         int i;
1489         int j;
1490         jpc_fix_t t;
1491
1492         if (stepsize == jpc_inttofix(1)) {
1493                 return;
1494         }
1495
1496         for (i = 0; i < jas_matrix_numrows(data); ++i) {
1497                 for (j = 0; j < jas_matrix_numcols(data); ++j) {
1498                         t = jas_matrix_get(data, i, j);
1499
1500 {
1501         if (t < 0) {
1502                 t = jpc_fix_neg(jpc_fix_div(jpc_fix_neg(t), stepsize));
1503         } else {
1504                 t = jpc_fix_div(t, stepsize);
1505         }
1506 }
1507
1508                         jas_matrix_set(data, i, j, t);
1509                 }
1510         }
1511 }
1512
1513 void calcrdslopes(jpc_enc_cblk_t *cblk)
1514 {
1515         jpc_enc_pass_t *endpasses;
1516         jpc_enc_pass_t *pass0;
1517         jpc_enc_pass_t *pass1;
1518         jpc_enc_pass_t *pass2;
1519         jpc_flt_t slope0;
1520         jpc_flt_t slope;
1521         jpc_flt_t dd;
1522         long dr;
1523
1524         endpasses = &cblk->passes[cblk->numpasses];
1525         pass2 = cblk->passes;
1526         slope0 = 0;
1527         while (pass2 != endpasses) {
1528                 pass0 = 0;
1529                 for (pass1 = cblk->passes; pass1 != endpasses; ++pass1) {
1530                         dd = pass1->cumwmsedec;
1531                         dr = pass1->end;
1532                         if (pass0) {
1533                                 dd -= pass0->cumwmsedec;
1534                                 dr -= pass0->end;
1535                         }
1536                         if (dd <= 0) {
1537                                 pass1->rdslope = JPC_BADRDSLOPE;
1538                                 if (pass1 >= pass2) {
1539                                         pass2 = &pass1[1];
1540                                 }
1541                                 continue;
1542                         }
1543                         if (pass1 < pass2 && pass1->rdslope <= 0) {
1544                                 continue;
1545                         }
1546                         if (!dr) {
1547                                 assert(pass0);
1548                                 pass0->rdslope = 0;
1549                                 break;
1550                         }
1551                         slope = dd / dr;
1552                         if (pass0 && slope >= slope0) {
1553                                 pass0->rdslope = 0;
1554                                 break;
1555                         }
1556                         pass1->rdslope = slope;
1557                         if (pass1 >= pass2) {
1558                                 pass2 = &pass1[1];
1559                         }
1560                         pass0 = pass1;
1561                         slope0 = slope;
1562                 }
1563         }
1564
1565 #if 0
1566         for (pass0 = cblk->passes; pass0 != endpasses; ++pass0) {
1567 if (pass0->rdslope > 0.0) {
1568                 jas_eprintf("pass %02d nmsedec=%lf dec=%lf end=%d %lf\n", pass0 - cblk->passes,
1569                   fixtodbl(pass0->nmsedec), pass0->wmsedec, pass0->end, pass0->rdslope);
1570 }
1571         }
1572 #endif
1573 }
1574
1575 void dump_layeringinfo(jpc_enc_t *enc)
1576 {
1577
1578         jpc_enc_tcmpt_t *tcmpt;
1579         int tcmptno;
1580         jpc_enc_rlvl_t *rlvl;
1581         int rlvlno;
1582         jpc_enc_band_t *band;
1583         int bandno;
1584         jpc_enc_prc_t *prc;
1585         int prcno;
1586         jpc_enc_cblk_t *cblk;
1587         int cblkno;
1588         jpc_enc_pass_t *pass;
1589         int passno;
1590         int lyrno;
1591         jpc_enc_tile_t *tile;
1592
1593         tile = enc->curtile;
1594
1595         for (lyrno = 0; lyrno < tile->numlyrs; ++lyrno) {
1596                 jas_eprintf("lyrno = %02d\n", lyrno);
1597                 for (tcmptno = 0, tcmpt = tile->tcmpts; tcmptno < tile->numtcmpts;
1598                   ++tcmptno, ++tcmpt) {
1599                         for (rlvlno = 0, rlvl = tcmpt->rlvls; rlvlno < tcmpt->numrlvls;
1600                           ++rlvlno, ++rlvl) {
1601                                 if (!rlvl->bands) {
1602                                         continue;
1603                                 }
1604                                 for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
1605                                   ++bandno, ++band) {
1606                                         if (!band->data) {
1607                                                 continue;
1608                                         }
1609                                         for (prcno = 0, prc = band->prcs; prcno < rlvl->numprcs;
1610                                           ++prcno, ++prc) {
1611                                                 if (!prc->cblks) {
1612                                                         continue;
1613                                                 }
1614                                                 for (cblkno = 0, cblk = prc->cblks; cblkno <
1615                                                   prc->numcblks; ++cblkno, ++cblk) {
1616                                                         for (passno = 0, pass = cblk->passes; passno <
1617                                                           cblk->numpasses && pass->lyrno == lyrno;
1618                                                           ++passno, ++pass) {
1619                                                                 jas_eprintf("lyrno=%02d cmptno=%02d rlvlno=%02d bandno=%02d prcno=%02d cblkno=%03d passno=%03d\n", lyrno, tcmptno, rlvlno, bandno, prcno, cblkno, passno);
1620                                                         }
1621                                                 }
1622                                         }
1623                                 }
1624                         }
1625                 }
1626         }
1627 }
1628
1629 int rateallocate(jpc_enc_t *enc, int numlyrs, uint_fast32_t *cumlens)
1630 {
1631         jpc_flt_t lo;
1632         jpc_flt_t hi;
1633         jas_stream_t *out;
1634         long cumlen;
1635         int lyrno;
1636         jpc_flt_t thresh;
1637         jpc_flt_t goodthresh;
1638         int success;
1639         long pos;
1640         long oldpos;
1641         int numiters;
1642
1643         jpc_enc_tcmpt_t *comp;
1644         jpc_enc_tcmpt_t *endcomps;
1645         jpc_enc_rlvl_t *lvl;
1646         jpc_enc_rlvl_t *endlvls;
1647         jpc_enc_band_t *band;
1648         jpc_enc_band_t *endbands;
1649         jpc_enc_cblk_t *cblk;
1650         jpc_enc_cblk_t *endcblks;
1651         jpc_enc_pass_t *pass;
1652         jpc_enc_pass_t *endpasses;
1653         jpc_enc_pass_t *pass1;
1654         jpc_flt_t mxrdslope;
1655         jpc_flt_t mnrdslope;
1656         jpc_enc_tile_t *tile;
1657         jpc_enc_prc_t *prc;
1658         int prcno;
1659
1660         tile = enc->curtile;
1661
1662         for (lyrno = 1; lyrno < numlyrs - 1; ++lyrno) {
1663                 if (cumlens[lyrno - 1] > cumlens[lyrno]) {
1664                         abort();
1665                 }
1666         }
1667
1668         if (!(out = jas_stream_memopen(0, 0))) {
1669                 return -1;
1670         }
1671
1672
1673         /* Find minimum and maximum R-D slope values. */
1674         mnrdslope = DBL_MAX;
1675         mxrdslope = 0;
1676         endcomps = &tile->tcmpts[tile->numtcmpts];
1677         for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1678                 endlvls = &comp->rlvls[comp->numrlvls];
1679                 for (lvl = comp->rlvls; lvl != endlvls; ++lvl) {
1680                         if (!lvl->bands) {
1681                                 continue;
1682                         }
1683                         endbands = &lvl->bands[lvl->numbands];
1684                         for (band = lvl->bands; band != endbands; ++band) {
1685                                 if (!band->data) {
1686                                         continue;
1687                                 }
1688                                 for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) {
1689                                         if (!prc->cblks) {
1690                                                 continue;
1691                                         }
1692                                         endcblks = &prc->cblks[prc->numcblks];
1693                                         for (cblk = prc->cblks; cblk != endcblks; ++cblk) {
1694                                                 calcrdslopes(cblk);
1695                                                 endpasses = &cblk->passes[cblk->numpasses];
1696                                                 for (pass = cblk->passes; pass != endpasses; ++pass) {
1697                                                         if (pass->rdslope > 0) {
1698                                                                 if (pass->rdslope < mnrdslope) {
1699                                                                         mnrdslope = pass->rdslope;
1700                                                                 }
1701                                                                 if (pass->rdslope > mxrdslope) {
1702                                                                         mxrdslope = pass->rdslope;
1703                                                                 }
1704                                                         }
1705                                                 }
1706                                         }
1707                                 }
1708                         }
1709                 }
1710         }
1711 if (jas_getdbglevel()) {
1712         jas_eprintf("min rdslope = %f max rdslope = %f\n", mnrdslope, mxrdslope);
1713 }
1714
1715         jpc_init_t2state(enc, 1);
1716
1717         for (lyrno = 0; lyrno < numlyrs; ++lyrno) {
1718
1719                 lo = mnrdslope;
1720                 hi = mxrdslope;
1721
1722                 success = 0;
1723                 goodthresh = 0;
1724                 numiters = 0;
1725
1726                 do {
1727
1728                         cumlen = cumlens[lyrno];
1729                         if (cumlen == UINT_FAST32_MAX) {
1730                                 /* Only the last layer can be free of a rate
1731                                   constraint (e.g., for lossless coding). */
1732                                 assert(lyrno == numlyrs - 1);
1733                                 goodthresh = -1;
1734                                 success = 1;
1735                                 break;
1736                         }
1737
1738                         thresh = (lo + hi) / 2;
1739
1740                         /* Save the tier 2 coding state. */
1741                         jpc_save_t2state(enc);
1742                         oldpos = jas_stream_tell(out);
1743                         assert(oldpos >= 0);
1744
1745                         /* Assign all passes with R-D slopes greater than or
1746                           equal to the current threshold to this layer. */
1747                         endcomps = &tile->tcmpts[tile->numtcmpts];
1748                         for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1749                                 endlvls = &comp->rlvls[comp->numrlvls];
1750                                 for (lvl = comp->rlvls; lvl != endlvls; ++lvl) {
1751                                         if (!lvl->bands) {
1752                                                 continue;
1753                                         }
1754                                         endbands = &lvl->bands[lvl->numbands];
1755                                         for (band = lvl->bands; band != endbands; ++band) {
1756                                                 if (!band->data) {
1757                                                         continue;
1758                                                 }
1759                                                 for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) {
1760                                                         if (!prc->cblks) {
1761                                                                 continue;
1762                                                         }
1763                                                         endcblks = &prc->cblks[prc->numcblks];
1764                                                         for (cblk = prc->cblks; cblk != endcblks; ++cblk) {
1765                                                                 if (cblk->curpass) {
1766                                                                         endpasses = &cblk->passes[cblk->numpasses];
1767                                                                         pass1 = cblk->curpass;
1768                                                                         for (pass = cblk->curpass; pass != endpasses; ++pass) {
1769                                                                                 if (pass->rdslope >= thresh) {
1770                                                                                         pass1 = &pass[1];
1771                                                                                 }
1772                                                                         }
1773                                                                         for (pass = cblk->curpass; pass != pass1; ++pass) {
1774                                                                                 pass->lyrno = lyrno;
1775                                                                         }
1776                                                                         for (; pass != endpasses; ++pass) {
1777                                                                                 pass->lyrno = -1;
1778                                                                         }
1779                                                                 }
1780                                                         }
1781                                                 }
1782                                         }
1783                                 }
1784                         }
1785
1786                         /* Perform tier 2 coding. */
1787                         endcomps = &tile->tcmpts[tile->numtcmpts];
1788                         for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1789                                 endlvls = &comp->rlvls[comp->numrlvls];
1790                                 for (lvl = comp->rlvls; lvl != endlvls; ++lvl) {
1791                                         if (!lvl->bands) {
1792                                                 continue;
1793                                         }
1794                                         for (prcno = 0; prcno < lvl->numprcs; ++prcno) {
1795                                                 if (jpc_enc_encpkt(enc, out, comp - tile->tcmpts, lvl - comp->rlvls, prcno, lyrno)) {
1796                                                         return -1;
1797                                                 }
1798                                         }
1799                                 }
1800                         }
1801
1802                         pos = jas_stream_tell(out);
1803
1804                         /* Check the rate constraint. */
1805                         assert(pos >= 0);
1806                         if (pos > cumlen) {
1807                                 /* The rate is too high. */
1808                                 lo = thresh;
1809                         } else if (pos <= cumlen) {
1810                                 /* The rate is low enough, so try higher. */
1811                                 hi = thresh;
1812                                 if (!success || thresh < goodthresh) {
1813                                         goodthresh = thresh;
1814                                         success = 1;
1815                                 }
1816                         }
1817
1818                         /* Save the tier 2 coding state. */
1819                         jpc_restore_t2state(enc);
1820                         if (jas_stream_seek(out, oldpos, SEEK_SET) < 0) {
1821                                 abort();
1822                         }
1823
1824 if (jas_getdbglevel()) {
1825 jas_eprintf("maxlen=%08ld actuallen=%08ld thresh=%f\n", cumlen, pos, thresh);
1826 }
1827
1828                         ++numiters;
1829                 } while (lo < hi - 1e-3 && numiters < 32);
1830
1831                 if (!success) {
1832                         jas_eprintf("warning: empty layer generated\n");
1833                 }
1834
1835 if (jas_getdbglevel()) {
1836 jas_eprintf("success %d goodthresh %f\n", success, goodthresh);
1837 }
1838
1839                 /* Assign all passes with R-D slopes greater than or
1840                   equal to the selected threshold to this layer. */
1841                 endcomps = &tile->tcmpts[tile->numtcmpts];
1842                 for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1843                         endlvls = &comp->rlvls[comp->numrlvls];
1844                         for (lvl = comp->rlvls; lvl != endlvls; ++lvl) {
1845 if (!lvl->bands) {
1846         continue;
1847 }
1848                                 endbands = &lvl->bands[lvl->numbands];
1849                                 for (band = lvl->bands; band != endbands; ++band) {
1850                                         if (!band->data) {
1851                                                 continue;
1852                                         }
1853                                         for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) {
1854                                                 if (!prc->cblks) {
1855                                                         continue;
1856                                                 }
1857                                                 endcblks = &prc->cblks[prc->numcblks];
1858                                                 for (cblk = prc->cblks; cblk != endcblks; ++cblk) {
1859                                                         if (cblk->curpass) {
1860                                                                 endpasses = &cblk->passes[cblk->numpasses];
1861                                                                 pass1 = cblk->curpass;
1862                                                                 if (success) {
1863                                                                         for (pass = cblk->curpass; pass != endpasses; ++pass) {
1864                                                                                 if (pass->rdslope >= goodthresh) {
1865                                                                                         pass1 = &pass[1];
1866                                                                                 }
1867                                                                         }
1868                                                                 }
1869                                                                 for (pass = cblk->curpass; pass != pass1; ++pass) {
1870                                                                         pass->lyrno = lyrno;
1871                                                                 }
1872                                                                 for (; pass != endpasses; ++pass) {
1873                                                                         pass->lyrno = -1;
1874                                                                 }
1875                                                         }
1876                                                 }
1877                                         }
1878                                 }
1879                         }
1880                 }
1881
1882                 /* Perform tier 2 coding. */
1883                 endcomps = &tile->tcmpts[tile->numtcmpts];
1884                 for (comp = tile->tcmpts; comp != endcomps; ++comp) {
1885                         endlvls = &comp->rlvls[comp->numrlvls];
1886                         for (lvl = comp->rlvls; lvl != endlvls; ++lvl) {
1887                                 if (!lvl->bands) {
1888                                         continue;
1889                                 }
1890                                 for (prcno = 0; prcno < lvl->numprcs; ++prcno) {
1891                                         if (jpc_enc_encpkt(enc, out, comp - tile->tcmpts, lvl - comp->rlvls, prcno, lyrno)) {
1892                                                 return -1;
1893                                         }
1894                                 }
1895                         }
1896                 }
1897         }
1898
1899         if (jas_getdbglevel() >= 5) {
1900                 dump_layeringinfo(enc);
1901         }
1902
1903         jas_stream_close(out);
1904
1905         JAS_DBGLOG(10, ("done doing rateallocation\n"));
1906 #if 0
1907 jas_eprintf("DONE RATE ALLOCATE\n");
1908 #endif
1909
1910         return 0;
1911 }
1912
1913 /******************************************************************************\
1914 * Tile constructors and destructors.
1915 \******************************************************************************/
1916
1917 jpc_enc_tile_t *jpc_enc_tile_create(jpc_enc_cp_t *cp, jas_image_t *image, int tileno)
1918 {
1919         jpc_enc_tile_t *tile;
1920         uint_fast32_t htileno;
1921         uint_fast32_t vtileno;
1922         uint_fast16_t lyrno;
1923         uint_fast16_t cmptno;
1924         jpc_enc_tcmpt_t *tcmpt;
1925
1926         if (!(tile = jas_malloc(sizeof(jpc_enc_tile_t)))) {
1927                 goto error;
1928         }
1929
1930         /* Initialize a few members used in error recovery. */
1931         tile->tcmpts = 0;
1932         tile->lyrsizes = 0;
1933         tile->numtcmpts = cp->numcmpts;
1934         tile->pi = 0;
1935
1936         tile->tileno = tileno;
1937         htileno = tileno % cp->numhtiles;
1938         vtileno = tileno / cp->numhtiles;
1939
1940         /* Calculate the coordinates of the top-left and bottom-right
1941           corners of the tile. */
1942         tile->tlx = JAS_MAX(cp->tilegrdoffx + htileno * cp->tilewidth,
1943           cp->imgareatlx);
1944         tile->tly = JAS_MAX(cp->tilegrdoffy + vtileno * cp->tileheight,
1945           cp->imgareatly);
1946         tile->brx = JAS_MIN(cp->tilegrdoffx + (htileno + 1) * cp->tilewidth,
1947           cp->refgrdwidth);
1948         tile->bry = JAS_MIN(cp->tilegrdoffy + (vtileno + 1) * cp->tileheight,
1949           cp->refgrdheight);
1950
1951         /* Initialize some tile coding parameters. */
1952         tile->intmode = cp->tcp.intmode;
1953         tile->csty = cp->tcp.csty;
1954         tile->prg = cp->tcp.prg;
1955         tile->mctid = cp->tcp.mctid;
1956
1957         tile->numlyrs = cp->tcp.numlyrs;
1958         if (!(tile->lyrsizes = jas_malloc(tile->numlyrs *
1959           sizeof(uint_fast32_t)))) {
1960                 goto error;
1961         }
1962         for (lyrno = 0; lyrno < tile->numlyrs; ++lyrno) {
1963                 tile->lyrsizes[lyrno] = 0;
1964         }
1965
1966         /* Allocate an array for the per-tile-component information. */
1967         if (!(tile->tcmpts = jas_malloc(cp->numcmpts * sizeof(jpc_enc_tcmpt_t)))) {
1968                 goto error;
1969         }
1970         /* Initialize a few members critical for error recovery. */
1971         for (cmptno = 0, tcmpt = tile->tcmpts; cmptno < cp->numcmpts;
1972           ++cmptno, ++tcmpt) {
1973                 tcmpt->rlvls = 0;
1974                 tcmpt->tsfb = 0;
1975                 tcmpt->data = 0;
1976         }
1977         /* Initialize the per-tile-component information. */
1978         for (cmptno = 0, tcmpt = tile->tcmpts; cmptno < cp->numcmpts;
1979           ++cmptno, ++tcmpt) {
1980                 if (!tcmpt_create(tcmpt, cp, image, tile)) {
1981                         goto error;
1982                 }
1983         }
1984
1985         /* Initialize the synthesis weights for the MCT. */
1986         switch (tile->mctid) {
1987         case JPC_MCT_RCT:
1988                 tile->tcmpts[0].synweight = jpc_dbltofix(sqrt(3.0));
1989                 tile->tcmpts[1].synweight = jpc_dbltofix(sqrt(0.6875));
1990                 tile->tcmpts[2].synweight = jpc_dbltofix(sqrt(0.6875));
1991                 break;
1992         case JPC_MCT_ICT:
1993                 tile->tcmpts[0].synweight = jpc_dbltofix(sqrt(3.0000));
1994                 tile->tcmpts[1].synweight = jpc_dbltofix(sqrt(3.2584));
1995                 tile->tcmpts[2].synweight = jpc_dbltofix(sqrt(2.4755));
1996                 break;
1997         default:
1998         case JPC_MCT_NONE:
1999                 for (cmptno = 0, tcmpt = tile->tcmpts; cmptno < cp->numcmpts;
2000                   ++cmptno, ++tcmpt) {
2001                         tcmpt->synweight = JPC_FIX_ONE;
2002                 }
2003                 break;
2004         }
2005
2006         if (!(tile->pi = jpc_enc_pi_create(cp, tile))) {
2007                 goto error;
2008         }
2009
2010         return tile;
2011
2012 error:
2013
2014         if (tile) {
2015                 jpc_enc_tile_destroy(tile);
2016         }
2017         return 0;
2018 }
2019
2020 void jpc_enc_tile_destroy(jpc_enc_tile_t *tile)
2021 {
2022         jpc_enc_tcmpt_t *tcmpt;
2023         uint_fast16_t cmptno;
2024
2025         if (tile->tcmpts) {
2026                 for (cmptno = 0, tcmpt = tile->tcmpts; cmptno <
2027                   tile->numtcmpts; ++cmptno, ++tcmpt) {
2028                         tcmpt_destroy(tcmpt);
2029                 }
2030                 jas_free(tile->tcmpts);
2031         }
2032         if (tile->lyrsizes) {
2033                 jas_free(tile->lyrsizes);
2034         }
2035         if (tile->pi) {
2036                 jpc_pi_destroy(tile->pi);
2037         }
2038         jas_free(tile);
2039 }
2040
2041 static jpc_enc_tcmpt_t *tcmpt_create(jpc_enc_tcmpt_t *tcmpt, jpc_enc_cp_t *cp,
2042   jas_image_t *image, jpc_enc_tile_t *tile)
2043 {
2044         uint_fast16_t cmptno;
2045         uint_fast16_t rlvlno;
2046         jpc_enc_rlvl_t *rlvl;
2047         uint_fast32_t tlx;
2048         uint_fast32_t tly;
2049         uint_fast32_t brx;
2050         uint_fast32_t bry;
2051         uint_fast32_t cmpttlx;
2052         uint_fast32_t cmpttly;
2053         jpc_enc_ccp_t *ccp;
2054         jpc_tsfb_band_t bandinfos[JPC_MAXBANDS];
2055
2056         tcmpt->tile = tile;
2057         tcmpt->tsfb = 0;
2058         tcmpt->data = 0;
2059         tcmpt->rlvls = 0;
2060
2061         /* Deduce the component number. */
2062         cmptno = tcmpt - tile->tcmpts;
2063
2064         ccp = &cp->ccps[cmptno];
2065
2066         /* Compute the coordinates of the top-left and bottom-right
2067           corners of this tile-component. */
2068         tlx = JPC_CEILDIV(tile->tlx, ccp->sampgrdstepx);
2069         tly = JPC_CEILDIV(tile->tly, ccp->sampgrdstepy);
2070         brx = JPC_CEILDIV(tile->brx, ccp->sampgrdstepx);
2071         bry = JPC_CEILDIV(tile->bry, ccp->sampgrdstepy);
2072
2073         /* Create a sequence to hold the tile-component sample data. */
2074         if (!(tcmpt->data = jas_seq2d_create(tlx, tly, brx, bry))) {
2075                 goto error;
2076         }
2077
2078         /* Get the image data associated with this tile-component. */
2079         cmpttlx = JPC_CEILDIV(cp->imgareatlx, ccp->sampgrdstepx);
2080         cmpttly = JPC_CEILDIV(cp->imgareatly, ccp->sampgrdstepy);
2081         if (jas_image_readcmpt(image, cmptno, tlx - cmpttlx, tly - cmpttly,
2082           brx - tlx, bry - tly, tcmpt->data)) {
2083                 goto error;
2084         }
2085
2086         tcmpt->synweight = 0;
2087         tcmpt->qmfbid = cp->tccp.qmfbid;
2088         tcmpt->numrlvls = cp->tccp.maxrlvls;
2089         tcmpt->numbands = 3 * tcmpt->numrlvls - 2;
2090         if (!(tcmpt->tsfb = jpc_cod_gettsfb(tcmpt->qmfbid, tcmpt->numrlvls - 1))) {
2091                 goto error;
2092         }
2093
2094         for (rlvlno = 0; rlvlno < tcmpt->numrlvls; ++rlvlno) {
2095                 tcmpt->prcwidthexpns[rlvlno] = cp->tccp.prcwidthexpns[rlvlno];
2096                 tcmpt->prcheightexpns[rlvlno] = cp->tccp.prcheightexpns[rlvlno];
2097         }
2098         tcmpt->cblkwidthexpn = cp->tccp.cblkwidthexpn;
2099         tcmpt->cblkheightexpn = cp->tccp.cblkheightexpn;
2100         tcmpt->cblksty = cp->tccp.cblksty;
2101         tcmpt->csty = cp->tccp.csty;
2102
2103         tcmpt->numstepsizes = tcmpt->numbands;
2104         assert(tcmpt->numstepsizes <= JPC_MAXBANDS);
2105         memset(tcmpt->stepsizes, 0, sizeof(tcmpt->numstepsizes *
2106           sizeof(uint_fast16_t)));
2107
2108         /* Retrieve information about the various bands. */
2109         jpc_tsfb_getbands(tcmpt->tsfb, jas_seq2d_xstart(tcmpt->data),
2110           jas_seq2d_ystart(tcmpt->data), jas_seq2d_xend(tcmpt->data),
2111           jas_seq2d_yend(tcmpt->data), bandinfos);
2112
2113         if (!(tcmpt->rlvls = jas_malloc(tcmpt->numrlvls * sizeof(jpc_enc_rlvl_t)))) {
2114                 goto error;
2115         }
2116         for (rlvlno = 0, rlvl = tcmpt->rlvls; rlvlno < tcmpt->numrlvls;
2117           ++rlvlno, ++rlvl) {
2118                 rlvl->bands = 0;
2119                 rlvl->tcmpt = tcmpt;
2120         }
2121         for (rlvlno = 0, rlvl = tcmpt->rlvls; rlvlno < tcmpt->numrlvls;
2122           ++rlvlno, ++rlvl) {
2123                 if (!rlvl_create(rlvl, cp, tcmpt, bandinfos)) {
2124                         goto error;
2125                 }
2126         }
2127
2128         return tcmpt;
2129
2130 error:
2131
2132         tcmpt_destroy(tcmpt);
2133         return 0;
2134
2135 }
2136
2137 static void tcmpt_destroy(jpc_enc_tcmpt_t *tcmpt)
2138 {
2139         jpc_enc_rlvl_t *rlvl;
2140         uint_fast16_t rlvlno;
2141
2142         if (tcmpt->rlvls) {
2143                 for (rlvlno = 0, rlvl = tcmpt->rlvls; rlvlno < tcmpt->numrlvls;
2144                   ++rlvlno, ++rlvl) {
2145                         rlvl_destroy(rlvl);
2146                 }
2147                 jas_free(tcmpt->rlvls);
2148         }
2149
2150         if (tcmpt->data) {
2151                 jas_seq2d_destroy(tcmpt->data);
2152         }
2153         if (tcmpt->tsfb) {
2154                 jpc_tsfb_destroy(tcmpt->tsfb);
2155         }
2156 }
2157
2158 static jpc_enc_rlvl_t *rlvl_create(jpc_enc_rlvl_t *rlvl, jpc_enc_cp_t *cp,
2159   jpc_enc_tcmpt_t *tcmpt, jpc_tsfb_band_t *bandinfos)
2160 {
2161         uint_fast16_t rlvlno;
2162         uint_fast32_t tlprctlx;
2163         uint_fast32_t tlprctly;
2164         uint_fast32_t brprcbrx;
2165         uint_fast32_t brprcbry;
2166         uint_fast16_t bandno;
2167         jpc_enc_band_t *band;
2168
2169         /* Deduce the resolution level. */
2170         rlvlno = rlvl - tcmpt->rlvls;
2171
2172         /* Initialize members required for error recovery. */
2173         rlvl->bands = 0;
2174         rlvl->tcmpt = tcmpt;
2175
2176         /* Compute the coordinates of the top-left and bottom-right
2177           corners of the tile-component at this resolution. */
2178         rlvl->tlx = JPC_CEILDIVPOW2(jas_seq2d_xstart(tcmpt->data), tcmpt->numrlvls -
2179           1 - rlvlno);
2180         rlvl->tly = JPC_CEILDIVPOW2(jas_seq2d_ystart(tcmpt->data), tcmpt->numrlvls -
2181           1 - rlvlno);
2182         rlvl->brx = JPC_CEILDIVPOW2(jas_seq2d_xend(tcmpt->data), tcmpt->numrlvls -
2183           1 - rlvlno);
2184         rlvl->bry = JPC_CEILDIVPOW2(jas_seq2d_yend(tcmpt->data), tcmpt->numrlvls -
2185           1 - rlvlno);
2186
2187         if (rlvl->tlx >= rlvl->brx || rlvl->tly >= rlvl->bry) {
2188                 rlvl->numhprcs = 0;
2189                 rlvl->numvprcs = 0;
2190                 rlvl->numprcs = 0;
2191                 return rlvl;
2192         }
2193
2194         rlvl->numbands = (!rlvlno) ? 1 : 3;
2195         rlvl->prcwidthexpn = cp->tccp.prcwidthexpns[rlvlno];
2196         rlvl->prcheightexpn = cp->tccp.prcheightexpns[rlvlno];
2197         if (!rlvlno) {
2198                 rlvl->cbgwidthexpn = rlvl->prcwidthexpn;
2199                 rlvl->cbgheightexpn = rlvl->prcheightexpn;
2200         } else {
2201                 rlvl->cbgwidthexpn = rlvl->prcwidthexpn - 1;
2202                 rlvl->cbgheightexpn = rlvl->prcheightexpn - 1;
2203         }
2204         rlvl->cblkwidthexpn = JAS_MIN(cp->tccp.cblkwidthexpn, rlvl->cbgwidthexpn);
2205         rlvl->cblkheightexpn = JAS_MIN(cp->tccp.cblkheightexpn, rlvl->cbgheightexpn);
2206
2207         /* Compute the number of precincts. */
2208         tlprctlx = JPC_FLOORTOMULTPOW2(rlvl->tlx, rlvl->prcwidthexpn);
2209         tlprctly = JPC_FLOORTOMULTPOW2(rlvl->tly, rlvl->prcheightexpn);
2210         brprcbrx = JPC_CEILTOMULTPOW2(rlvl->brx, rlvl->prcwidthexpn);
2211         brprcbry = JPC_CEILTOMULTPOW2(rlvl->bry, rlvl->prcheightexpn);
2212         rlvl->numhprcs = JPC_FLOORDIVPOW2(brprcbrx - tlprctlx, rlvl->prcwidthexpn);
2213         rlvl->numvprcs = JPC_FLOORDIVPOW2(brprcbry - tlprctly, rlvl->prcheightexpn);
2214         rlvl->numprcs = rlvl->numhprcs * rlvl->numvprcs;
2215
2216         if (!(rlvl->bands = jas_malloc(rlvl->numbands * sizeof(jpc_enc_band_t)))) {
2217                 goto error;
2218         }
2219         for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
2220           ++bandno, ++band) {
2221                 band->prcs = 0;
2222                 band->data = 0;
2223                 band->rlvl = rlvl;
2224         }
2225         for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
2226           ++bandno, ++band) {
2227                 if (!band_create(band, cp, rlvl, bandinfos)) {
2228                         goto error;
2229                 }
2230         }
2231
2232         return rlvl;
2233 error:
2234
2235         rlvl_destroy(rlvl);
2236         return 0;
2237 }
2238
2239 static void rlvl_destroy(jpc_enc_rlvl_t *rlvl)
2240 {
2241         jpc_enc_band_t *band;
2242         uint_fast16_t bandno;
2243
2244         if (rlvl->bands) {
2245                 for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
2246                   ++bandno, ++band) {
2247                         band_destroy(band);
2248                 }
2249                 jas_free(rlvl->bands);
2250         }
2251 }
2252
2253 static jpc_enc_band_t *band_create(jpc_enc_band_t *band, jpc_enc_cp_t *cp,
2254   jpc_enc_rlvl_t *rlvl, jpc_tsfb_band_t *bandinfos)
2255 {
2256         uint_fast16_t bandno;
2257         uint_fast16_t gblbandno;
2258         uint_fast16_t rlvlno;
2259         jpc_tsfb_band_t *bandinfo;
2260         jpc_enc_tcmpt_t *tcmpt;
2261         uint_fast32_t prcno;
2262         jpc_enc_prc_t *prc;
2263
2264         tcmpt = rlvl->tcmpt;
2265         band->data = 0;
2266         band->prcs = 0;
2267         band->rlvl = rlvl;
2268
2269         /* Deduce the resolution level and band number. */
2270         rlvlno = rlvl - rlvl->tcmpt->rlvls;
2271         bandno = band - rlvl->bands;
2272         gblbandno = (!rlvlno) ? 0 : (3 * (rlvlno - 1) + bandno + 1);
2273
2274         bandinfo = &bandinfos[gblbandno];
2275
2276 if (bandinfo->xstart != bandinfo->xend && bandinfo->ystart != bandinfo->yend) {
2277         if (!(band->data = jas_seq2d_create(0, 0, 0, 0))) {
2278                 goto error;
2279         }
2280         jas_seq2d_bindsub(band->data, tcmpt->data, bandinfo->locxstart,
2281           bandinfo->locystart, bandinfo->locxend, bandinfo->locyend);
2282         jas_seq2d_setshift(band->data, bandinfo->xstart, bandinfo->ystart);
2283 }
2284         band->orient = bandinfo->orient;
2285         band->analgain = JPC_NOMINALGAIN(cp->tccp.qmfbid, tcmpt->numrlvls, rlvlno,
2286           band->orient);
2287         band->numbps = 0;
2288         band->absstepsize = 0;
2289         band->stepsize = 0;
2290         band->synweight = bandinfo->synenergywt;
2291
2292 if (band->data) {
2293         if (!(band->prcs = jas_malloc(rlvl->numprcs * sizeof(jpc_enc_prc_t)))) {
2294                 goto error;
2295         }
2296         for (prcno = 0, prc = band->prcs; prcno < rlvl->numprcs; ++prcno,
2297           ++prc) {
2298                 prc->cblks = 0;
2299                 prc->incltree = 0;
2300                 prc->nlibtree = 0;
2301                 prc->savincltree = 0;
2302                 prc->savnlibtree = 0;
2303                 prc->band = band;
2304         }
2305         for (prcno = 0, prc = band->prcs; prcno < rlvl->numprcs; ++prcno,
2306           ++prc) {
2307                 if (!prc_create(prc, cp, band)) {
2308                         goto error;
2309                 }
2310         }
2311 }
2312
2313         return band;
2314
2315 error:
2316         band_destroy(band);
2317         return 0;
2318 }
2319
2320 static void band_destroy(jpc_enc_band_t *band)
2321 {
2322         jpc_enc_prc_t *prc;
2323         jpc_enc_rlvl_t *rlvl;
2324         uint_fast32_t prcno;
2325
2326         if (band->prcs) {
2327                 rlvl = band->rlvl;
2328                 for (prcno = 0, prc = band->prcs; prcno < rlvl->numprcs;
2329                   ++prcno, ++prc) {
2330                         prc_destroy(prc);
2331                 }
2332                 jas_free(band->prcs);
2333         }
2334         if (band->data) {
2335                 jas_seq2d_destroy(band->data);
2336         }
2337 }
2338
2339 static jpc_enc_prc_t *prc_create(jpc_enc_prc_t *prc, jpc_enc_cp_t *cp, jpc_enc_band_t *band)
2340 {
2341         uint_fast32_t prcno;
2342         uint_fast32_t prcxind;
2343         uint_fast32_t prcyind;
2344         uint_fast32_t cbgtlx;
2345         uint_fast32_t cbgtly;
2346         uint_fast32_t tlprctlx;
2347         uint_fast32_t tlprctly;
2348         uint_fast32_t tlcbgtlx;
2349         uint_fast32_t tlcbgtly;
2350         uint_fast16_t rlvlno;
2351         jpc_enc_rlvl_t *rlvl;
2352         uint_fast32_t tlcblktlx;
2353         uint_fast32_t tlcblktly;
2354         uint_fast32_t brcblkbrx;
2355         uint_fast32_t brcblkbry;
2356         uint_fast32_t cblkno;
2357         jpc_enc_cblk_t *cblk;
2358         jpc_enc_tcmpt_t *tcmpt;
2359
2360         prc->cblks = 0;
2361         prc->incltree = 0;
2362         prc->savincltree = 0;
2363         prc->nlibtree = 0;
2364         prc->savnlibtree = 0;
2365
2366         rlvl = band->rlvl;
2367         tcmpt = rlvl->tcmpt;
2368 rlvlno = rlvl - tcmpt->rlvls;
2369         prcno = prc - band->prcs;
2370         prcxind = prcno % rlvl->numhprcs;
2371         prcyind = prcno / rlvl->numhprcs;
2372         prc->band = band;
2373
2374 tlprctlx = JPC_FLOORTOMULTPOW2(rlvl->tlx, rlvl->prcwidthexpn);
2375 tlprctly = JPC_FLOORTOMULTPOW2(rlvl->tly, rlvl->prcheightexpn);
2376 if (!rlvlno) {
2377         tlcbgtlx = tlprctlx;
2378         tlcbgtly = tlprctly;
2379 } else {
2380         tlcbgtlx = JPC_CEILDIVPOW2(tlprctlx, 1);
2381         tlcbgtly = JPC_CEILDIVPOW2(tlprctly, 1);
2382 }
2383
2384         /* Compute the coordinates of the top-left and bottom-right
2385           corners of the precinct. */
2386         cbgtlx = tlcbgtlx + (prcxind << rlvl->cbgwidthexpn);
2387         cbgtly = tlcbgtly + (prcyind << rlvl->cbgheightexpn);
2388         prc->tlx = JAS_MAX(jas_seq2d_xstart(band->data), cbgtlx);
2389         prc->tly = JAS_MAX(jas_seq2d_ystart(band->data), cbgtly);
2390         prc->brx = JAS_MIN(jas_seq2d_xend(band->data), cbgtlx +
2391           (1 << rlvl->cbgwidthexpn));
2392         prc->bry = JAS_MIN(jas_seq2d_yend(band->data), cbgtly +
2393           (1 << rlvl->cbgheightexpn));
2394
2395         if (prc->tlx < prc->brx && prc->tly < prc->bry) {
2396                 /* The precinct contains at least one code block. */
2397
2398                 tlcblktlx = JPC_FLOORTOMULTPOW2(prc->tlx, rlvl->cblkwidthexpn);
2399                 tlcblktly = JPC_FLOORTOMULTPOW2(prc->tly, rlvl->cblkheightexpn);
2400                 brcblkbrx = JPC_CEILTOMULTPOW2(prc->brx, rlvl->cblkwidthexpn);
2401                 brcblkbry = JPC_CEILTOMULTPOW2(prc->bry, rlvl->cblkheightexpn);
2402                 prc->numhcblks = JPC_FLOORDIVPOW2(brcblkbrx - tlcblktlx,
2403                   rlvl->cblkwidthexpn);
2404                 prc->numvcblks = JPC_FLOORDIVPOW2(brcblkbry - tlcblktly,
2405                   rlvl->cblkheightexpn);
2406                 prc->numcblks = prc->numhcblks * prc->numvcblks;
2407
2408                 if (!(prc->incltree = jpc_tagtree_create(prc->numhcblks,
2409                   prc->numvcblks))) {
2410                         goto error;
2411                 }
2412                 if (!(prc->nlibtree = jpc_tagtree_create(prc->numhcblks,
2413                   prc->numvcblks))) {
2414                         goto error;
2415                 }
2416                 if (!(prc->savincltree = jpc_tagtree_create(prc->numhcblks,
2417                   prc->numvcblks))) {
2418                         goto error;
2419                 }
2420                 if (!(prc->savnlibtree = jpc_tagtree_create(prc->numhcblks,
2421                   prc->numvcblks))) {
2422                         goto error;
2423                 }
2424
2425                 if (!(prc->cblks = jas_malloc(prc->numcblks * sizeof(jpc_enc_cblk_t)))) {
2426                         goto error;
2427                 }
2428                 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
2429                   ++cblkno, ++cblk) {
2430                         cblk->passes = 0;
2431                         cblk->stream = 0;
2432                         cblk->mqenc = 0;
2433                         cblk->data = 0;
2434                         cblk->flags = 0;
2435                         cblk->prc = prc;
2436                 }
2437                 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
2438                   ++cblkno, ++cblk) {
2439                         if (!cblk_create(cblk, cp, prc)) {
2440                                 goto error;
2441                         }
2442                 }
2443         } else {
2444                 /* The precinct does not contain any code blocks. */
2445                 prc->tlx = prc->brx;
2446                 prc->tly = prc->bry;
2447                 prc->numcblks = 0;
2448                 prc->numhcblks = 0;
2449                 prc->numvcblks = 0;
2450                 prc->cblks = 0;
2451                 prc->incltree = 0;
2452                 prc->nlibtree = 0;
2453                 prc->savincltree = 0;
2454                 prc->savnlibtree = 0;
2455         }
2456
2457         return prc;
2458
2459 error:
2460         prc_destroy(prc);
2461         return 0;
2462 }
2463
2464 static void prc_destroy(jpc_enc_prc_t *prc)
2465 {
2466         jpc_enc_cblk_t *cblk;
2467         uint_fast32_t cblkno;
2468
2469         if (prc->cblks) {
2470                 for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
2471                   ++cblkno, ++cblk) {
2472                         cblk_destroy(cblk);
2473                 }
2474                 jas_free(prc->cblks);
2475         }
2476         if (prc->incltree) {
2477                 jpc_tagtree_destroy(prc->incltree);
2478         }
2479         if (prc->nlibtree) {
2480                 jpc_tagtree_destroy(prc->nlibtree);
2481         }
2482         if (prc->savincltree) {
2483                 jpc_tagtree_destroy(prc->savincltree);
2484         }
2485         if (prc->savnlibtree) {
2486                 jpc_tagtree_destroy(prc->savnlibtree);
2487         }
2488 }
2489
2490 static jpc_enc_cblk_t *cblk_create(jpc_enc_cblk_t *cblk, jpc_enc_cp_t *cp, jpc_enc_prc_t *prc)
2491 {
2492         jpc_enc_band_t *band;
2493         uint_fast32_t cblktlx;
2494         uint_fast32_t cblktly;
2495         uint_fast32_t cblkbrx;
2496         uint_fast32_t cblkbry;
2497         jpc_enc_rlvl_t *rlvl;
2498         uint_fast32_t cblkxind;
2499         uint_fast32_t cblkyind;
2500         uint_fast32_t cblkno;
2501         uint_fast32_t tlcblktlx;
2502         uint_fast32_t tlcblktly;
2503
2504         cblkno = cblk - prc->cblks;
2505         cblkxind = cblkno % prc->numhcblks;
2506         cblkyind = cblkno / prc->numhcblks;
2507         rlvl = prc->band->rlvl;
2508         cblk->prc = prc;
2509
2510         cblk->numpasses = 0;
2511         cblk->passes = 0;
2512         cblk->numencpasses = 0;
2513         cblk->numimsbs = 0;
2514         cblk->numlenbits = 0;
2515         cblk->stream = 0;
2516         cblk->mqenc = 0;
2517         cblk->flags = 0;
2518         cblk->numbps = 0;
2519         cblk->curpass = 0;
2520         cblk->data = 0;
2521         cblk->savedcurpass = 0;
2522         cblk->savednumlenbits = 0;
2523         cblk->savednumencpasses = 0;
2524
2525         band = prc->band;
2526         tlcblktlx = JPC_FLOORTOMULTPOW2(prc->tlx, rlvl->cblkwidthexpn);
2527         tlcblktly = JPC_FLOORTOMULTPOW2(prc->tly, rlvl->cblkheightexpn);
2528         cblktlx = JAS_MAX(tlcblktlx + (cblkxind << rlvl->cblkwidthexpn), prc->tlx);
2529         cblktly = JAS_MAX(tlcblktly + (cblkyind << rlvl->cblkheightexpn), prc->tly);
2530         cblkbrx = JAS_MIN(tlcblktlx + ((cblkxind + 1) << rlvl->cblkwidthexpn),
2531           prc->brx);
2532         cblkbry = JAS_MIN(tlcblktly + ((cblkyind + 1) << rlvl->cblkheightexpn),
2533           prc->bry);
2534
2535         assert(cblktlx < cblkbrx && cblktly < cblkbry);
2536         if (!(cblk->data = jas_seq2d_create(0, 0, 0, 0))) {
2537                 goto error;
2538         }
2539         jas_seq2d_bindsub(cblk->data, band->data, cblktlx, cblktly, cblkbrx, cblkbry);
2540
2541         return cblk;
2542
2543 error:
2544         cblk_destroy(cblk);
2545         return 0;
2546 }
2547
2548 static void cblk_destroy(jpc_enc_cblk_t *cblk)
2549 {
2550         uint_fast16_t passno;
2551         jpc_enc_pass_t *pass;
2552         if (cblk->passes) {
2553                 for (passno = 0, pass = cblk->passes; passno < cblk->numpasses;
2554                   ++passno, ++pass) {
2555                         pass_destroy(pass);
2556                 }
2557                 jas_free(cblk->passes);
2558         }
2559         if (cblk->stream) {
2560                 jas_stream_close(cblk->stream);
2561         }
2562         if (cblk->mqenc) {
2563                 jpc_mqenc_destroy(cblk->mqenc);
2564         }
2565         if (cblk->data) {
2566                 jas_seq2d_destroy(cblk->data);
2567         }
2568         if (cblk->flags) {
2569                 jas_seq2d_destroy(cblk->flags);
2570         }
2571 }
2572
2573 static void pass_destroy(jpc_enc_pass_t *pass)
2574 {
2575         /* XXX - need to free resources here */
2576 }
2577
2578 void jpc_enc_dump(jpc_enc_t *enc)
2579 {
2580         jpc_enc_tile_t *tile;
2581         jpc_enc_tcmpt_t *tcmpt;
2582         jpc_enc_rlvl_t *rlvl;
2583         jpc_enc_band_t *band;
2584         jpc_enc_prc_t *prc;
2585         jpc_enc_cblk_t *cblk;
2586         uint_fast16_t cmptno;
2587         uint_fast16_t rlvlno;
2588         uint_fast16_t bandno;
2589         uint_fast32_t prcno;
2590         uint_fast32_t cblkno;
2591
2592         tile = enc->curtile;
2593
2594         for (cmptno = 0, tcmpt = tile->tcmpts; cmptno < tile->numtcmpts; ++cmptno,
2595           ++tcmpt) {
2596                 jas_eprintf("  tcmpt %5d %5d %5d %5d\n", jas_seq2d_xstart(tcmpt->data), jas_seq2d_ystart(tcmpt->data), jas_seq2d_xend(tcmpt->data), jas_seq2d_yend(tcmpt->data));
2597                 for (rlvlno = 0, rlvl = tcmpt->rlvls; rlvlno < tcmpt->numrlvls;
2598                   ++rlvlno, ++rlvl) {
2599                         jas_eprintf("    rlvl %5d %5d %5d %5d\n", rlvl->tlx, rlvl->tly, rlvl->brx, rlvl->bry);
2600                         for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
2601                           ++bandno, ++band) {
2602                                 if (!band->data) {
2603                                         continue;
2604                                 }
2605                                 jas_eprintf("      band %5d %5d %5d %5d\n", jas_seq2d_xstart(band->data), jas_seq2d_ystart(band->data), jas_seq2d_xend(band->data), jas_seq2d_yend(band->data));
2606                                 for (prcno = 0, prc = band->prcs; prcno < rlvl->numprcs;
2607                                   ++prcno, ++prc) {
2608                                         jas_eprintf("        prc %5d %5d %5d %5d (%5d %5d)\n", prc->tlx, prc->tly, prc->brx, prc->bry, prc->brx - prc->tlx, prc->bry - prc->tly);
2609                                         if (!prc->cblks) {
2610                                                 continue;
2611                                         }
2612                                         for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
2613                                           ++cblkno, ++cblk) {
2614                                                 jas_eprintf("         cblk %5d %5d %5d %5d\n", jas_seq2d_xstart(cblk->data), jas_seq2d_ystart(cblk->data), jas_seq2d_xend(cblk->data), jas_seq2d_yend(cblk->data));
2615                                         }
2616                                 }
2617                         }
2618                 }
2619         }
2620 }