src/gdcmjpegls/Decoder/initialize.c

   1 /* SPMG/JPEG-LS IMPLEMENTATION V.2.1
   2    =====================================
   3    These programs are Copyright (c) University of British Columbia. All rights reserved.
   4    They may be freely redistributed in their entirety provided that this copyright
   5    notice is not removed.  THEY MAY NOT BE SOLD FOR PROFIT OR INCORPORATED IN
   6    COMMERCIAL PROGRAMS WITHOUT THE WRITTEN PERMISSION OF THE COPYRIGHT HOLDER.
   7    Each program is provided as is, without any express or implied warranty,
   8    without even the warranty of fitness for a particular purpose.
   9
  10    =========================================================
  11    THIS SOFTWARE IS BASED ON HP's implementation of jpeg-ls:
  12    =========================================================
  13
  14    LOCO-I/JPEG-LS IMPLEMENTATION V.0.90
  15    -------------------------------------------------------------------------------
  16    (c) COPYRIGHT HEWLETT-PACKARD COMPANY, 1995-1999.
  17         HEWLETT-PACKARD COMPANY ("HP") DOES NOT WARRANT THE ACCURACY OR
  18    COMPLETENESS OF THE INFORMATION GIVEN HERE.  ANY USE MADE OF, OR
  19    RELIANCE ON, SUCH INFORMATION IS ENTIRELY AT USER'S OWN RISK.
  20         BY DOWNLOADING THE LOCO-I/JPEG-LS COMPRESSORS/DECOMPRESSORS
  21    ("THE SOFTWARE") YOU AGREE TO BE BOUND BY THE TERMS AND CONDITIONS
  22    OF THIS LICENSING AGREEMENT.
  23         YOU MAY DOWNLOAD AND USE THE SOFTWARE FOR NON-COMMERCIAL PURPOSES
  24    FREE OF CHARGE OR FURTHER OBLIGATION.  YOU MAY NOT, DIRECTLY OR
  25    INDIRECTLY, DISTRIBUTE THE SOFTWARE FOR A FEE, INCORPORATE THIS
  26    SOFTWARE INTO ANY PRODUCT OFFERED FOR SALE, OR USE THE SOFTWARE
  27    TO PROVIDE A SERVICE FOR WHICH A FEE IS CHARGED.
  28         YOU MAY MAKE COPIES OF THE SOFTWARE AND DISTRIBUTE SUCH COPIES TO
  29    OTHER PERSONS PROVIDED THAT SUCH COPIES ARE ACCOMPANIED BY
  30    HEWLETT-PACKARD'S COPYRIGHT NOTICE AND THIS AGREEMENT AND THAT
  31    SUCH OTHER PERSONS AGREE TO BE BOUND BY THE TERMS OF THIS AGREEMENT.
  32         THE SOFTWARE IS NOT OF PRODUCT QUALITY AND MAY HAVE ERRORS OR DEFECTS.
  33    THE JPEG-LS STANDARD IS STILL UNDER DEVELOPMENT. THE SOFTWARE IS NOT A
  34    FINAL OR FULL IMPLEMENTATION OF THE STANDARD.  HP GIVES NO EXPRESS OR
  35    IMPLIED WARRANTY OF ANY KIND AND ANY IMPLIED WARRANTIES OF
  36    MERCHANTABILITY AND FITNESS FOR PURPOSE ARE DISCLAIMED.
  37         HP SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
  38    OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE.
  39    -------------------------------------------------------------------------------
  40 */
  41
  42 /* initialize.c --- functions to initialize look up tables
  43  *                  and statistics tables
  44  *
  45  * Initial code by Alex Jakulin,  Aug. 1995
  46  *
  47  * Modified and optimized: Gadiel Seroussi, October 1995
  48  *
  49  *
  50  * Modified and added Restart marker and input tables by:
  51  * David Cheng-Hsiu Chu, and Ismail R. Ismail march 1999
  52  */
  53
  54 #include <stdio.h>
  55 #include <math.h>
  56
  57 #include "global.h"
  58 #include "bitio.h"
  59
  60
  61
  62 int vLUT[3][2 * LUTMAX16];
  63
  64 int classmap[CONTEXTS1];
  65
  66 int  *qdiv0, *qdiv,        /* quantization table (division via look-up) */
  67   *qmul0, *qmul;        /* dequantization table */
  68
  69 int N[TOT_CONTEXTS],
  70     A[TOT_CONTEXTS],
  71     B[TOT_CONTEXTS],
  72   C[TOT_CONTEXTS];
  73
  74
  75
  76 /* Setup Look Up Tables for quantized gradient merging */
  77 void prepareLUTs()
  78 {
  79   int i, j, idx, lmax;
  80   byte k;
  81
  82   lmax = min(alpha,lutmax);
  83
  84   /* implementation limitation: */
  85   if ( T3 > lmax-1 ) {
  86     fprintf(stderr,"Sorry, current implementation does not support threshold T3 > %d, got %d\n",lmax-1,T3);
  87     exit(10);
  88   }
  89
  90
  91   /* Build classification tables (lossless or lossy) */
  92
  93   if (lossy==FALSE) {
  94
  95     for (i = -lmax + 1; i < lmax; i++) {
  96
  97       if  ( i <= -T3 )        /* ...... -T3  */
  98         idx = 7;
  99       else if ( i <= -T2 )    /* -(T3-1) ... -T2 */
 100         idx = 5;
 101       else if ( i <= -T1 )    /* -(T2-1) ... -T1 */
 102         idx = 3;
 103
 104       else if ( i <= -1 )     /* -(T1-1) ...  -1 */
 105         idx = 1;
 106       else if ( i == 0 )      /*  just 0 */
 107         idx = 0;
 108
 109       else if ( i < T1 )      /* 1 ... T1-1 */
 110         idx = 2;
 111       else if ( i < T2 )      /* T1 ... T2-1 */
 112         idx = 4;
 113       else if ( i < T3 )      /* T2 ... T3-1 */
 114         idx = 6;
 115       else                    /* T3 ... */
 116         idx = 8;
 117
 118       vLUT[0][i + lutmax] = CREGIONS * CREGIONS * idx;
 119       vLUT[1][i + lutmax] = CREGIONS * idx;
 120       vLUT[2][i + lutmax] = idx;
 121     }
 122
 123   } else {
 124
 125     for (i = -lmax + 1; i < lmax; i++) {
 126
 127       if ( NEAR >= (alpha-1) )
 128         idx = 0;   /* degenerate case, regardless of thresholds */
 129       else
 130
 131         if  ( i <= -T3 )        /* ...... -T3  */
 132           idx = 7;
 133         else if ( i <= -T2 )    /* -(T3-1) ... -T2 */
 134           idx = 5;
 135         else if ( i <= -T1 )    /* -(T2-1) ... -T1 */
 136           idx = 3;
 137
 138         else if ( i <= -NEAR-1 )     /* -(T1-1) ...  -NEAR-1 */
 139           idx = 1;
 140         else if ( i <= NEAR )      /*  within NEAR of 0 */
 141           idx = 0;
 142
 143         else if ( i < T1 )      /* 1 ... T1-1 */
 144           idx = 2;
 145         else if ( i < T2 )      /* T1 ... T2-1 */
 146           idx = 4;
 147         else if ( i < T3 )      /* T2 ... T3-1 */
 148           idx = 6;
 149         else                    /* T3 ... */
 150           idx = 8;
 151
 152       vLUT[0][i + lutmax] = CREGIONS * CREGIONS * idx;
 153       vLUT[1][i + lutmax] = CREGIONS * idx;
 154       vLUT[2][i + lutmax] = idx;
 155     }
 156
 157   }
 158
 159
 160   /*  prepare context mapping table (symmetric context merging) */
 161   classmap[0] = 0;
 162   for ( i=1, j=0; i<CONTEXTS1; i++) {
 163       int q1, q2, q3, n1=0, n2=0, n3=0, ineg, sgn;
 164
 165       if(classmap[i])
 166       continue;
 167
 168       q1 = i/(CREGIONS*CREGIONS);    /* first digit */
 169       q2 = (i/CREGIONS)%CREGIONS;    /* second digit */
 170       q3 = i%CREGIONS;          /* third digit */
 171
 172       if((q1%2)||(q1==0 && (q2%2))||(q1==0 && q2==0 && (q3%2)))
 173       sgn = -1;
 174       else
 175       sgn = 1;
 176
 177       /* compute negative context */
 178       if(q1) n1 = q1 + ((q1%2) ? 1 : -1);
 179       if(q2) n2 = q2 + ((q2%2) ? 1 : -1);
 180       if(q3) n3 = q3 + ((q3%2) ? 1 : -1);
 181
 182       ineg = (n1*CREGIONS+n2)*CREGIONS+n3;
 183       j++ ;    /* next class number */
 184       classmap[i] = sgn*j;
 185       classmap[ineg] = -sgn*j;
 186
 187   }
 188
 189 }
 190
 191
 192
 193
 194
 195
 196 /* prepare quantization tables for near-lossless quantization */
 197 void prepare_qtables(int absize, int NEAR)
 198 {
 199     int diff, qdiff;
 200     int beta, quant;
 201
 202     quant = 2*NEAR+1;
 203     beta = absize;
 204
 205     if ( (qdiv0 = (int *)calloc(2*absize-1,sizeof(int)))==NULL ) {
 206       perror("qdiv  table");
 207       exit(10);
 208     }
 209     qdiv = qdiv0+absize-1;
 210
 211     if ( (qmul0 = (int *)calloc(2*beta-1,sizeof(int)))==NULL ) {
 212       perror("qmul  table");
 213       exit(10);
 214     }
 215     qmul = qmul0+beta-1;
 216
 217     for ( diff = -(absize-1); diff<absize; diff++ ) {
 218       if ( diff<0 )
 219         qdiff = - ( (NEAR-diff)/quant );
 220       else
 221         qdiff = ( NEAR + diff )/quant;
 222       qdiv[diff] = qdiff;
 223     }
 224     for ( qdiff = -(beta-1); qdiff<beta; qdiff++ ) {
 225       diff = quant*qdiff;
 226       qmul[qdiff] = diff;
 227     }
 228 }
 229
 230
 231
 232
 233 /* Initialize A[], B[], C[], and N[] arrays */
 234 void init_stats(int absize)
 235 {
 236
 237   int i, initabstat, slack;
 238
 239   slack = 1<<INITABSLACK;
 240   initabstat = (absize + slack/2)/slack;
 241   if ( initabstat < MIN_INITABSTAT ) initabstat = MIN_INITABSTAT;
 242
 243   /* do the statistics initialization */
 244   for (i = 0; i < TOT_CONTEXTS; ++i) {
 245     C[i]= B[i] = 0;
 246     N[i] = INITNSTAT;
 247     A[i] = initabstat;
 248   }
 249 }
 250
 251
 252