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
  81   lmax = min(alpha,lutmax);
  82
  83   /* implementation limitation: */
  84   if ( T3 > lmax-1 ) {
  85     fprintf(stderr,"Sorry, current implementation does not support threshold T3 > %d, got %d\n",lmax-1,T3);
  86     exit(10);
  87   }
  88
  89
  90   /* Build classification tables (lossless or lossy) */
  91
  92   if (lossy==FALSE) {
  93
  94     for (i = -lmax + 1; i < lmax; i++) {
  95
  96       if  ( i <= -T3 )        /* ...... -T3  */
  97         idx = 7;
  98       else if ( i <= -T2 )    /* -(T3-1) ... -T2 */
  99         idx = 5;
 100       else if ( i <= -T1 )    /* -(T2-1) ... -T1 */
 101         idx = 3;
 102
 103       else if ( i <= -1 )     /* -(T1-1) ...  -1 */
 104         idx = 1;
 105       else if ( i == 0 )      /*  just 0 */
 106         idx = 0;
 107
 108       else if ( i < T1 )      /* 1 ... T1-1 */
 109         idx = 2;
 110       else if ( i < T2 )      /* T1 ... T2-1 */
 111         idx = 4;
 112       else if ( i < T3 )      /* T2 ... T3-1 */
 113         idx = 6;
 114       else                    /* T3 ... */
 115         idx = 8;
 116
 117       vLUT[0][i + lutmax] = CREGIONS * CREGIONS * idx;
 118       vLUT[1][i + lutmax] = CREGIONS * idx;
 119       vLUT[2][i + lutmax] = idx;
 120     }
 121
 122   } else {
 123
 124     for (i = -lmax + 1; i < lmax; i++) {
 125
 126       if ( NEAR >= (alpha-1) )
 127         idx = 0;   /* degenerate case, regardless of thresholds */
 128       else
 129
 130         if  ( i <= -T3 )        /* ...... -T3  */
 131           idx = 7;
 132         else if ( i <= -T2 )    /* -(T3-1) ... -T2 */
 133           idx = 5;
 134         else if ( i <= -T1 )    /* -(T2-1) ... -T1 */
 135           idx = 3;
 136
 137         else if ( i <= -NEAR-1 )     /* -(T1-1) ...  -NEAR-1 */
 138           idx = 1;
 139         else if ( i <= NEAR )      /*  within NEAR of 0 */
 140           idx = 0;
 141
 142         else if ( i < T1 )      /* 1 ... T1-1 */
 143           idx = 2;
 144         else if ( i < T2 )      /* T1 ... T2-1 */
 145           idx = 4;
 146         else if ( i < T3 )      /* T2 ... T3-1 */
 147           idx = 6;
 148         else                    /* T3 ... */
 149           idx = 8;
 150
 151       vLUT[0][i + lutmax] = CREGIONS * CREGIONS * idx;
 152       vLUT[1][i + lutmax] = CREGIONS * idx;
 153       vLUT[2][i + lutmax] = idx;
 154     }
 155
 156   }
 157
 158
 159   /*  prepare context mapping table (symmetric context merging) */
 160   classmap[0] = 0;
 161   for ( i=1, j=0; i<CONTEXTS1; i++) {
 162       int q1, q2, q3, n1=0, n2=0, n3=0, ineg, sgn;
 163
 164       if(classmap[i])
 165       continue;
 166
 167       q1 = i/(CREGIONS*CREGIONS);    /* first digit */
 168       q2 = (i/CREGIONS)%CREGIONS;    /* second digit */
 169       q3 = i%CREGIONS;          /* third digit */
 170
 171       if((q1%2)||(q1==0 && (q2%2))||(q1==0 && q2==0 && (q3%2)))
 172       sgn = -1;
 173       else
 174       sgn = 1;
 175
 176       /* compute negative context */
 177       if(q1) n1 = q1 + ((q1%2) ? 1 : -1);
 178       if(q2) n2 = q2 + ((q2%2) ? 1 : -1);
 179       if(q3) n3 = q3 + ((q3%2) ? 1 : -1);
 180
 181       ineg = (n1*CREGIONS+n2)*CREGIONS+n3;
 182       j++ ;    /* next class number */
 183       classmap[i] = sgn*j;
 184       classmap[ineg] = -sgn*j;
 185
 186   }
 187
 188 }
 189
 190
 191
 192
 193
 194
 195 /* prepare quantization tables for near-lossless quantization */
 196 void prepare_qtables(int absize, int NEAR)
 197 {
 198     int diff, qdiff;
 199     int beta, quant;
 200
 201     quant = 2*NEAR+1;
 202     beta = absize;
 203
 204     if ( (qdiv0 = (int *)calloc(2*absize-1,sizeof(int)))==NULL ) {
 205       perror("qdiv  table");
 206       exit(10);
 207     }
 208     qdiv = qdiv0+absize-1;
 209
 210     if ( (qmul0 = (int *)calloc(2*beta-1,sizeof(int)))==NULL ) {
 211       perror("qmul  table");
 212       exit(10);
 213     }
 214     qmul = qmul0+beta-1;
 215
 216     for ( diff = -(absize-1); diff<absize; diff++ ) {
 217       if ( diff<0 )
 218         qdiff = - ( (NEAR-diff)/quant );
 219       else
 220         qdiff = ( NEAR + diff )/quant;
 221       qdiv[diff] = qdiff;
 222     }
 223     for ( qdiff = -(beta-1); qdiff<beta; qdiff++ ) {
 224       diff = quant*qdiff;
 225       qmul[qdiff] = diff;
 226     }
 227 }
 228
 229
 230
 231
 232 /* Initialize A[], B[], C[], and N[] arrays */
 233 void init_stats(int absize)
 234 {
 235
 236   int i, initabstat, slack;
 237
 238   slack = 1<<INITABSLACK;
 239   initabstat = (absize + slack/2)/slack;
 240   if ( initabstat < MIN_INITABSTAT ) initabstat = MIN_INITABSTAT;
 241
 242   /* do the statistics initialization */
 243   for (i = 0; i < TOT_CONTEXTS; ++i) {
 244     C[i]= B[i] = 0;
 245     N[i] = INITNSTAT;
 246     A[i] = initabstat;
 247   }
 248 }
 249
 250
 251