src/gdcmjpegls/Decoder/global.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 /* global.c --- support and portability routines: error handling, safe memory
  43  *                              management, etc.
  44  *
  45  * Initial code by Alex Jakulin,  Aug. 1995
  46  *
  47  * Modified and optimized: Gadiel Seroussi, October 1995 - ...
  48  *
  49  * Modified and added Restart marker and input tables by:
  50  * David Cheng-Hsiu Chu, and Ismail R. Ismail march 1999
  51  */
  52
  53 #include <time.h>
  54 #include "global.h"
  55 #ifdef HAVE_UNISTD_H
  56 #include <unistd.h>
  57 #else
  58 #include <io.h>
  59 #endif
  60
  61
  62
  63 char disclaimer[] = "\
  64 This program is Copyright (c) University of British Columbia.\n\
  65 All rights reserved. It may be freely redistributed in its\n\
  66 entirety provided that this copyright notice is not removed.\n\
  67 It may not be sold for profit or incorporated in commercial programs\n\
  68 without the written permission of the copyright holder.\n\
  69 ";
  70
  71
  72
  73 /* I/O files */
  74 FILE *in, *out;
  75 FILE *c_in[MAX_COMPONENTS];
  76 FILE *c_out[MAX_COMPONENTS];
  77 FILE *msgfile = NULL; /* = stdout;*/
  78
  79 /* Context quantization thresholds  - initially unset */
  80 int     T3 = -1,
  81         T2 = -1,
  82         T1 = -1,
  83     Ta = -1;
  84
  85
  86 int verbose = 1;   /* verbosity level */
  87 int nopause = 0;   /* whether to pause the legal notice or not */
  88 int nolegal = 0;   /* whether to print the legal notice or not */
  89
  90
  91 /* parameters for LOSSY images */
  92 int  quant,          /* quantization = 2*NEAR+1 */
  93   beta,    /* size of extended alphabet */
  94   qbeta,          /* size of quantized alphabet */
  95   ceil_half_qbeta, /* ceil(qbeta/2) */
  96   negNEAR,            /* -NEAR */
  97   alpha1eps;       /* alpha-1+NEAR */
  98
  99 int  NEAR = DEF_NEAR;   /* loss tolerance per symbol, fixed at 0 for lossless */
 100 int bpp,    /* bits per sample */
 101   qbpp,   /* bits per sample for quantized prediction errors */
 102     limit,  /* limit for unary part of Golomb code */
 103     limit_reduce;  /* reduction on above for EOR states */
 104
 105
 106
 107
 108 /* function to print out error messages */
 109 void error(const char *msg) {
 110   fprintf(stderr, msg);
 111   exit(-1);
 112 }
 113
 114
 115 /* function to safely call malloc */
 116 void *safealloc(size_t size) {
 117   void *temp;
 118
 119   temp = malloc(size);
 120     if (temp == NULL)
 121     error("\nsafealloc: Out of memory. Aborting...\n");
 122   return temp;
 123 }
 124
 125
 126 /* function to safely call calloc **/
 127 void *safecalloc(size_t numels, size_t size) {
 128   void *temp;
 129
 130   temp = calloc(numels, size);
 131     if (temp == NULL)
 132     error("\nsafecalloc: Out of memory. Aborting...\n");
 133   return temp;
 134 }
 135
 136
 137 /*
 138  * TIMING ROUTINES
 139  */
 140
 141
 142 double get_utime()
 143 {
 144   /*clock_t c;
 145   (void)c;*/
 146
 147   return (double)clock()/CLOCKS_PER_SEC;
 148 }
 149
 150
 151 /* Set thresholds to default unless specified by header: */
 152 int set_thresholds(int alfa, int NEAR, int *T1p, int *T2p, int *T3p)
 153 {
 154   int lambda,
 155       ilambda = 256/alfa,
 156       quant = 2*NEAR+1,
 157       T1 = *T1p,
 158       T2 = *T2p,
 159       T3 = *T3p;
 160   /* Unused */
 161   (void)quant;
 162
 163   if (alfa<4096)
 164      lambda = (alfa+127)/256;
 165         else
 166      lambda = (4096+127)/256;
 167
 168
 169
 170   if ( T1 <= 0 )  {
 171     /* compute lossless default */
 172     if ( lambda )
 173       T1 = lambda*(BASIC_T1 - 2) + 2;
 174     else {  /* alphabet < 8 bits */
 175       T1 = BASIC_T1/ilambda;
 176       if ( T1 < 2 ) T1 = 2;
 177     }
 178     /* adjust for lossy */
 179     T1 += 3*NEAR;
 180
 181     /* check that the default threshold is in bounds */
 182     if ( T1 < NEAR+1 || T1 > (alfa-1) )
 183          T1 = NEAR+1;         /* eliminates the threshold */
 184   }
 185   if ( T2 <= 0 )  {
 186     /* compute lossless default */
 187     if ( lambda )
 188       T2 = lambda*(BASIC_T2 - 3) + 3;
 189     else {
 190       T2 = BASIC_T2/ilambda;
 191       if ( T2 < 3 ) T2 = 3;
 192     }
 193     /* adjust for lossy */
 194     T2 += 5*NEAR;
 195
 196     /* check that the default threshold is in bounds */
 197     if ( T2 < T1 || T2 > (alfa-1) )
 198          T2 = T1;         /* eliminates the threshold */
 199   }
 200   if ( T3 <= 0 )  {
 201     /* compute lossless default */
 202     if ( lambda )
 203       T3 = lambda*(BASIC_T3 - 4) + 4;
 204     else {
 205       T3 = BASIC_T3/ilambda;
 206       if ( T3 < 4 ) T3 = 4;
 207     }
 208     /* adjust for lossy */
 209     T3 += 7*NEAR;
 210
 211     /* check that the default threshold is in bounds */
 212     if ( T3 < T2 || T3 > (alfa-1) )
 213          T3 = T2;         /* eliminates the threshold */
 214   }
 215
 216   *T1p = T1;
 217   *T2p = T2;
 218   *T3p = T3;
 219   return 0;
 220 }
 221
 222
 223
 224
 225 /* We first check compatibility with JPEG-LS, then with this implementation */
 226
 227 void check_compatibility(jpeg_ls_header *head_frame, jpeg_ls_header *head_scan, int n_s)
 228 {
 229
 230     int  number_of_scans,i;
 231     int maxreset;
 232
 233 /* Check implemented color modes */
 234     if ((head_scan->color_mode>PIXEL_INT)) {
 235   fprintf(stderr,"Color mode %d not supported\n",head_scan->color_mode);
 236   exit(10);
 237     }
 238
 239     if (head_scan->color_mode==PLANE_INT)
 240   number_of_scans=head_frame->comp;
 241     else
 242   number_of_scans=1;
 243
 244
 245 /* Test standard compatibility */
 246
 247     if (head_frame->columns<=0 || head_frame->rows <=0) {
 248   fprintf(stderr,"Image size must be positive for this implementation.\n");
 249   exit(10);
 250     }
 251
 252     if (head_frame->alp<4) {
 253   fprintf(stderr,"Alphabet size must be >= 4, got %d\n",head_frame->alp);
 254   exit(10);
 255     }
 256
 257
 258     if (head_scan->T1>head_scan->T2 || head_scan->T2>head_scan->T3 ||
 259   head_scan->T1<head_scan->NEAR+1 || head_scan->T3>=head_scan->alp ) {
 260   fprintf(stderr,"Bad thresholds: must be %d <= Ta <= Tb <= Tc <= %d\n",
 261       head_scan->NEAR+1,head_scan->alp-1);
 262   exit(10);
 263     }
 264
 265     if (head_frame->comp>255) {
 266   fprintf(stderr,"Too many components (must be less than 255)\n");
 267   exit(10);
 268     }
 269
 270     if (head_scan->NEAR>=head_scan->alp) {
 271   fprintf(stderr,"Error for near-lossless must be smaller than alphabet (%d), got %d",head_scan->alp,head_scan->NEAR);
 272   exit(10);
 273     }
 274
 275     /*
 276     if (head_scan->RES < MINRESET || head_scan->RES >= head_scan->alp ) {
 277   fprintf(stderr,"Reset parameter must be between %d and %d\n",
 278           MINRESET, head_scan->alp-1);
 279   exit(10);
 280     }
 281     */
 282
 283     maxreset = (head_scan->alp >= 256)? (head_scan->alp-1):255;
 284
 285     if (head_scan->RES < MINRESET || head_scan->RES > maxreset ) {
 286   fprintf(stderr,"Reset parameter must be between %d and %d\n",
 287           MINRESET, head_scan->alp-1);
 288   exit(10);
 289     }
 290
 291     for (i=0;i<head_frame->comp;i++)
 292   if (head_frame->comp_ids[i] != (i+1)) {
 293      fprintf(stderr,"Components id in frame not compatible with this implementation.\n");
 294      exit(10);
 295         }
 296
 297     if (number_of_scans == 1) {
 298   if (head_frame->comp != head_scan->comp) {
 299      fprintf(stderr,"In this implementation, when single scan, all components must be in the scan.\n");
 300      exit(10);
 301         }
 302         for (i=0;i<head_frame->comp;i++)
 303     if (head_scan->comp_ids[i] != (i+1)) {
 304        fprintf(stderr,"Components id in single scan not compatible with this implementation.\n");
 305        exit(10);
 306           }
 307
 308     }
 309     else {
 310   if (head_scan->comp != 1) {
 311      fprintf(stderr,"Only 1 component per scan for plane interleaved mode\n");
 312      exit(10);
 313         }
 314         if (head_scan->comp_ids[0] != (n_s+1)) {
 315      fprintf(stderr,"Components id in multiple scan not compatible with this implementation.\n");
 316      exit(10);
 317         }
 318
 319     }
 320 }
 321
 322
 323 /* for writing disclaimer to command line in DOS */
 324
 325 char ttyfilename[] = "CON";
 326
 327 #define PAUSE  20
 328
 329 void fprint_disclaimer(FILE *fp, int nopause)
 330 {
 331   char *p0, *p1;
 332   FILE *ttyf = NULL;
 333   int  i; /*, c;*/
 334
 335   nopause = nopause | !isatty(fileno(fp));
 336
 337   if ( !nopause && (ttyf=fopen(ttyfilename,"r"))==NULL ) {
 338     nopause = 1;
 339   }
 340
 341   for ( i=1, p0=disclaimer; ; i++ ) {
 342     if ( !(*p0)  ) break;
 343     if ( !nopause && i%PAUSE==0 ) {
 344       fflush(fp);
 345       fprintf(stderr, "--- (press RETURN to continue) ---");
 346       fflush(stderr);
 347 /*      c = getc(ttyf);*/
 348     }
 349     for ( p1=p0; (*p1 != '\n') && (*p1 != 0); p1++ );
 350     *p1 = 0;
 351     fprintf(fp,"%s\n",p0);
 352     p0 = p1+1;
 353   }
 354   fprintf(fp,"\n"); fflush(fp);
 355   if ( !nopause) fclose(ttyf);
 356 }