git.maemo.org Git - opencv/blob - 3rdparty/libjasper/jpc_t1cod.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_t1cod.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
  77 #include "jasper/jas_types.h"
  78 #include "jasper/jas_math.h"
  79
  80 #include "jpc_bs.h"
  81 #include "jpc_dec.h"
  82 #include "jpc_cs.h"
  83 #include "jpc_mqcod.h"
  84 #include "jpc_t1cod.h"
  85 #include "jpc_tsfb.h"
  86
  87 double jpc_pow2i(int n);
  88
  89 /******************************************************************************\
  90 * Global data.
  91 \******************************************************************************/
  92
  93 int jpc_zcctxnolut[4 * 256];
  94 int jpc_spblut[256];
  95 int jpc_scctxnolut[256];
  96 int jpc_magctxnolut[4096];
  97
  98 jpc_fix_t jpc_signmsedec[1 << JPC_NMSEDEC_BITS];
  99 jpc_fix_t jpc_refnmsedec[1 << JPC_NMSEDEC_BITS];
 100 jpc_fix_t jpc_signmsedec0[1 << JPC_NMSEDEC_BITS];
 101 jpc_fix_t jpc_refnmsedec0[1 << JPC_NMSEDEC_BITS];
 102
 103 jpc_mqctx_t jpc_mqctxs[JPC_NUMCTXS];
 104
 105 /******************************************************************************\
 106 *
 107 \******************************************************************************/
 108
 109 void jpc_initmqctxs(void);
 110
 111 /******************************************************************************\
 112 * Code.
 113 \******************************************************************************/
 114
 115 int JPC_PASSTYPE(int passno)
 116 {
 117         int passtype;
 118         switch (passno % 3) {
 119         case 0:
 120                 passtype = JPC_CLNPASS;
 121                 break;
 122         case 1:
 123                 passtype = JPC_SIGPASS;
 124                 break;
 125         case 2:
 126                 passtype = JPC_REFPASS;
 127                 break;
 128         default:
 129                 passtype = -1;
 130                 assert(0);
 131                 break;
 132         }
 133         return passtype;
 134 }
 135
 136 int JPC_NOMINALGAIN(int qmfbid, int numlvls, int lvlno, int orient)
 137 {
 138         /* Avoid compiler warnings about unused parameters. */
 139         numlvls = 0;
 140
 141 if (qmfbid == JPC_COX_INS) {
 142         return 0;
 143 }
 144         assert(qmfbid == JPC_COX_RFT);
 145         if (lvlno == 0) {
 146                 assert(orient == JPC_TSFB_LL);
 147                 return 0;
 148         } else {
 149                 switch (orient) {
 150                 case JPC_TSFB_LH:
 151                 case JPC_TSFB_HL:
 152                         return 1;
 153                         break;
 154                 case JPC_TSFB_HH:
 155                         return 2;
 156                         break;
 157                 }
 158         }
 159         abort();
 160 }
 161
 162 /******************************************************************************\
 163 * Coding pass related functions.
 164 \******************************************************************************/
 165
 166 int JPC_SEGTYPE(int passno, int firstpassno, int bypass)
 167 {
 168         int passtype;
 169         if (bypass) {
 170                 passtype = JPC_PASSTYPE(passno);
 171                 if (passtype == JPC_CLNPASS) {
 172                         return JPC_SEG_MQ;
 173                 }
 174                 return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW);
 175         } else {
 176                 return JPC_SEG_MQ;
 177         }
 178 }
 179
 180 int JPC_SEGPASSCNT(int passno, int firstpassno, int numpasses, int bypass, int termall)
 181 {
 182         int ret;
 183         int passtype;
 184
 185         if (termall) {
 186                 ret = 1;
 187         } else if (bypass) {
 188                 if (passno < firstpassno + 10) {
 189                         ret = 10 - (passno - firstpassno);
 190                 } else {
 191                         passtype = JPC_PASSTYPE(passno);
 192                         switch (passtype) {
 193                         case JPC_SIGPASS:
 194                                 ret = 2;
 195                                 break;
 196                         case JPC_REFPASS:
 197                                 ret = 1;
 198                                 break;
 199                         case JPC_CLNPASS:
 200                                 ret = 1;
 201                                 break;
 202                         default:
 203                                 ret = -1;
 204                                 assert(0);
 205                                 break;
 206                         }
 207                 }
 208         } else {
 209                 ret = JPC_PREC * 3 - 2;
 210         }
 211         ret = JAS_MIN(ret, numpasses - passno);
 212         return ret;
 213 }
 214
 215 int JPC_ISTERMINATED(int passno, int firstpassno, int numpasses, int termall,
 216   int lazy)
 217 {
 218         int ret;
 219         int n;
 220         if (passno - firstpassno == numpasses - 1) {
 221                 ret = 1;
 222         } else {
 223                 n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall);
 224                 ret = (n <= 1) ? 1 : 0;
 225         }
 226
 227         return ret;
 228 }
 229
 230 /******************************************************************************\
 231 * Lookup table code.
 232 \******************************************************************************/
 233
 234 void jpc_initluts()
 235 {
 236         int i;
 237         int orient;
 238         int refine;
 239         float u;
 240         float v;
 241         float t;
 242
 243 /* XXX - hack */
 244 jpc_initmqctxs();
 245
 246         for (orient = 0; orient < 4; ++orient) {
 247                 for (i = 0; i < 256; ++i) {
 248                         jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient);
 249                 }
 250         }
 251
 252         for (i = 0; i < 256; ++i) {
 253                 jpc_spblut[i] = jpc_getspb(i << 4);
 254         }
 255
 256         for (i = 0; i < 256; ++i) {
 257                 jpc_scctxnolut[i] = jpc_getscctxno(i << 4);
 258         }
 259
 260         for (refine = 0; refine < 2; ++refine) {
 261                 for (i = 0; i < 2048; ++i) {
 262                         jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i);
 263                 }
 264         }
 265
 266         for (i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) {
 267                 t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS);
 268                 u = t;
 269                 v = t - 1.5;
 270                 jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 271 /* XXX - this calc is not correct */
 272                 jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 273                 u = t - 1.0;
 274                 if (i & (1 << (JPC_NMSEDEC_BITS - 1))) {
 275                         v = t - 1.5;
 276                 } else {
 277                         v = t - 0.5;
 278                 }
 279                 jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 280 /* XXX - this calc is not correct */
 281                 jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
 282         }
 283 }
 284
 285 jpc_fix_t jpc_getsignmsedec_func(jpc_fix_t x, int bitpos)
 286 {
 287         jpc_fix_t y;
 288         assert(!(x & (~JAS_ONES(bitpos + 1))));
 289         y = jpc_getsignmsedec_macro(x, bitpos);
 290         return y;
 291 }
 292
 293 int jpc_getzcctxno(int f, int orient)
 294 {
 295         int h;
 296         int v;
 297         int d;
 298         int n;
 299         int t;
 300         int hv;
 301
 302         /* Avoid compiler warning. */
 303         n = 0;
 304
 305         h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0);
 306         v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0);
 307         d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0);
 308         switch (orient) {
 309         case JPC_TSFB_HL:
 310                 t = h;
 311                 h = v;
 312                 v = t;
 313         case JPC_TSFB_LL:
 314         case JPC_TSFB_LH:
 315                 if (!h) {
 316                         if (!v) {
 317                                 if (!d) {
 318                                         n = 0;
 319                                 } else if (d == 1) {
 320                                         n = 1;
 321                                 } else {
 322                                         n = 2;
 323                                 }
 324                         } else if (v == 1) {
 325                                 n = 3;
 326                         } else {
 327                                 n = 4;
 328                         }
 329                 } else if (h == 1) {
 330                         if (!v) {
 331                                 if (!d) {
 332                                         n = 5;
 333                                 } else {
 334                                         n = 6;
 335                                 }
 336                         } else {
 337                                 n = 7;
 338                         }
 339                 } else {
 340                         n = 8;
 341                 }
 342                 break;
 343         case JPC_TSFB_HH:
 344                 hv = h + v;
 345                 if (!d) {
 346                         if (!hv) {
 347                                 n = 0;
 348                         } else if (hv == 1) {
 349                                 n = 1;
 350                         } else {
 351                                 n = 2;
 352                         }
 353                 } else if (d == 1) {
 354                         if (!hv) {
 355                                 n = 3;
 356                         } else if (hv == 1) {
 357                                 n = 4;
 358                         } else {
 359                                 n = 5;
 360                         }
 361                 } else if (d == 2) {
 362                         if (!hv) {
 363                                 n = 6;
 364                         } else {
 365                                 n = 7;
 366                         }
 367                 } else {
 368                         n = 8;
 369                 }
 370                 break;
 371         }
 372         assert(n < JPC_NUMZCCTXS);
 373         return JPC_ZCCTXNO + n;
 374 }
 375
 376 int jpc_getspb(int f)
 377 {
 378         int hc;
 379         int vc;
 380         int n;
 381
 382         hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) -
 383           JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
 384         vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) -
 385           JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
 386         if (!hc && !vc) {
 387                 n = 0;
 388         } else {
 389                 n = (!(hc > 0 || (!hc && vc > 0)));
 390         }
 391         return n;
 392 }
 393
 394 int jpc_getscctxno(int f)
 395 {
 396         int hc;
 397         int vc;
 398         int n;
 399
 400         /* Avoid compiler warning. */
 401         n = 0;
 402
 403         hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG),
 404           1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) +
 405           ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
 406         vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG),
 407           1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) +
 408           ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
 409         assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1);
 410         if (hc < 0) {
 411                 hc = -hc;
 412                 vc = -vc;
 413         }
 414         if (!hc) {
 415                 if (vc == -1) {
 416                         n = 1;
 417                 } else if (!vc) {
 418                         n = 0;
 419                 } else {
 420                         n = 1;
 421                 }
 422         } else if (hc == 1) {
 423                 if (vc == -1) {
 424                         n = 2;
 425                 } else if (!vc) {
 426                         n = 3;
 427                 } else {
 428                         n = 4;
 429                 }
 430         }
 431         assert(n < JPC_NUMSCCTXS);
 432         return JPC_SCCTXNO + n;
 433 }
 434
 435 int jpc_getmagctxno(int f)
 436 {
 437         int n;
 438
 439         if (!(f & JPC_REFINE)) {
 440                 n = (f & (JPC_OTHSIGMSK)) ? 1 : 0;
 441         } else {
 442                 n = 2;
 443         }
 444
 445         assert(n < JPC_NUMMAGCTXS);
 446         return JPC_MAGCTXNO + n;
 447 }
 448
 449 void jpc_initctxs(jpc_mqctx_t *ctxs)
 450 {
 451         jpc_mqctx_t *ctx;
 452         int i;
 453
 454         ctx = ctxs;
 455         for (i = 0; i < JPC_NUMCTXS; ++i) {
 456                 ctx->mps = 0;
 457                 switch (i) {
 458                 case JPC_UCTXNO:
 459                         ctx->ind = 46;
 460                         break;
 461                 case JPC_ZCCTXNO:
 462                         ctx->ind = 4;
 463                         break;
 464                 case JPC_AGGCTXNO:
 465                         ctx->ind = 3;
 466                         break;
 467                 default:
 468                         ctx->ind = 0;
 469                         break;
 470                 }
 471                 ++ctx;
 472         }
 473 }
 474
 475 void jpc_initmqctxs()
 476 {
 477         jpc_initctxs(jpc_mqctxs);
 478 }
 479
 480 /* Calculate the real quantity exp2(n), where x is an integer. */
 481 double jpc_pow2i(int n)
 482 {
 483         double x;
 484         double a;
 485
 486         x = 1.0;
 487         if (n < 0) {
 488                 a = 0.5;
 489                 n = -n;
 490         } else {
 491                 a = 2.0;
 492         }
 493         while (--n >= 0) {
 494                 x *= a;
 495         }
 496         return x;
 497 }