rdswitch.c

   1 /*
   2  * rdswitch.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1991-1996, Thomas G. Lane.
   6  * libjpeg-turbo Modifications:
   7  * Copyright (C) 2010, 2018, D. R. Commander.
   8  * For conditions of distribution and use, see the accompanying README.ijg
   9  * file.
  10  *
  11  * This file contains routines to process some of cjpeg's more complicated
  12  * command-line switches.  Switches processed here are:
  13  *      -qtables file           Read quantization tables from text file
  14  *      -scans file             Read scan script from text file
  15  *      -quality N[,N,...]      Set quality ratings
  16  *      -qslots N[,N,...]       Set component quantization table selectors
  17  *      -sample HxV[,HxV,...]   Set component sampling factors
  18  */
  19
  20 #include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
  21 #include <ctype.h>              /* to declare isdigit(), isspace() */
  22
  23
  24 LOCAL(int)
  25 text_getc(FILE *file)
  26 /* Read next char, skipping over any comments (# to end of line) */
  27 /* A comment/newline sequence is returned as a newline */
  28 {
  29   register int ch;
  30
  31   ch = getc(file);
  32   if (ch == '#') {
  33     do {
  34       ch = getc(file);
  35     } while (ch != '\n' && ch != EOF);
  36   }
  37   return ch;
  38 }
  39
  40
  41 LOCAL(boolean)
  42 read_text_integer(FILE *file, long *result, int *termchar)
  43 /* Read an unsigned decimal integer from a file, store it in result */
  44 /* Reads one trailing character after the integer; returns it in termchar */
  45 {
  46   register int ch;
  47   register long val;
  48
  49   /* Skip any leading whitespace, detect EOF */
  50   do {
  51     ch = text_getc(file);
  52     if (ch == EOF) {
  53       *termchar = ch;
  54       return FALSE;
  55     }
  56   } while (isspace(ch));
  57
  58   if (!isdigit(ch)) {
  59     *termchar = ch;
  60     return FALSE;
  61   }
  62
  63   val = ch - '0';
  64   while ((ch = text_getc(file)) != EOF) {
  65     if (!isdigit(ch))
  66       break;
  67     val *= 10;
  68     val += ch - '0';
  69   }
  70   *result = val;
  71   *termchar = ch;
  72   return TRUE;
  73 }
  74
  75
  76 #if JPEG_LIB_VERSION < 70
  77 static int q_scale_factor[NUM_QUANT_TBLS] = { 100, 100, 100, 100 };
  78 #endif
  79
  80 GLOBAL(boolean)
  81 read_quant_tables(j_compress_ptr cinfo, char *filename, boolean force_baseline)
  82 /* Read a set of quantization tables from the specified file.
  83  * The file is plain ASCII text: decimal numbers with whitespace between.
  84  * Comments preceded by '#' may be included in the file.
  85  * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.
  86  * The tables are implicitly numbered 0,1,etc.
  87  * NOTE: does not affect the qslots mapping, which will default to selecting
  88  * table 0 for luminance (or primary) components, 1 for chrominance components.
  89  * You must use -qslots if you want a different component->table mapping.
  90  */
  91 {
  92   FILE *fp;
  93   int tblno, i, termchar;
  94   long val;
  95   unsigned int table[DCTSIZE2];
  96
  97   if ((fp = fopen(filename, "r")) == NULL) {
  98     fprintf(stderr, "Can't open table file %s\n", filename);
  99     return FALSE;
 100   }
 101   tblno = 0;
 102
 103   while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */
 104     if (tblno >= NUM_QUANT_TBLS) {
 105       fprintf(stderr, "Too many tables in file %s\n", filename);
 106       fclose(fp);
 107       return FALSE;
 108     }
 109     table[0] = (unsigned int)val;
 110     for (i = 1; i < DCTSIZE2; i++) {
 111       if (!read_text_integer(fp, &val, &termchar)) {
 112         fprintf(stderr, "Invalid table data in file %s\n", filename);
 113         fclose(fp);
 114         return FALSE;
 115       }
 116       table[i] = (unsigned int)val;
 117     }
 118 #if JPEG_LIB_VERSION >= 70
 119     jpeg_add_quant_table(cinfo, tblno, table, cinfo->q_scale_factor[tblno],
 120                          force_baseline);
 121 #else
 122     jpeg_add_quant_table(cinfo, tblno, table, q_scale_factor[tblno],
 123                          force_baseline);
 124 #endif
 125     tblno++;
 126   }
 127
 128   if (termchar != EOF) {
 129     fprintf(stderr, "Non-numeric data in file %s\n", filename);
 130     fclose(fp);
 131     return FALSE;
 132   }
 133
 134   fclose(fp);
 135   return TRUE;
 136 }
 137
 138
 139 #ifdef C_MULTISCAN_FILES_SUPPORTED
 140
 141 LOCAL(boolean)
 142 read_scan_integer(FILE *file, long *result, int *termchar)
 143 /* Variant of read_text_integer that always looks for a non-space termchar;
 144  * this simplifies parsing of punctuation in scan scripts.
 145  */
 146 {
 147   register int ch;
 148
 149   if (!read_text_integer(file, result, termchar))
 150     return FALSE;
 151   ch = *termchar;
 152   while (ch != EOF && isspace(ch))
 153     ch = text_getc(file);
 154   if (isdigit(ch)) {            /* oops, put it back */
 155     if (ungetc(ch, file) == EOF)
 156       return FALSE;
 157     ch = ' ';
 158   } else {
 159     /* Any separators other than ';' and ':' are ignored;
 160      * this allows user to insert commas, etc, if desired.
 161      */
 162     if (ch != EOF && ch != ';' && ch != ':')
 163       ch = ' ';
 164   }
 165   *termchar = ch;
 166   return TRUE;
 167 }
 168
 169
 170 GLOBAL(boolean)
 171 read_scan_script(j_compress_ptr cinfo, char *filename)
 172 /* Read a scan script from the specified text file.
 173  * Each entry in the file defines one scan to be emitted.
 174  * Entries are separated by semicolons ';'.
 175  * An entry contains one to four component indexes,
 176  * optionally followed by a colon ':' and four progressive-JPEG parameters.
 177  * The component indexes denote which component(s) are to be transmitted
 178  * in the current scan.  The first component has index 0.
 179  * Sequential JPEG is used if the progressive-JPEG parameters are omitted.
 180  * The file is free format text: any whitespace may appear between numbers
 181  * and the ':' and ';' punctuation marks.  Also, other punctuation (such
 182  * as commas or dashes) can be placed between numbers if desired.
 183  * Comments preceded by '#' may be included in the file.
 184  * Note: we do very little validity checking here;
 185  * jcmaster.c will validate the script parameters.
 186  */
 187 {
 188   FILE *fp;
 189   int scanno, ncomps, termchar;
 190   long val;
 191   jpeg_scan_info *scanptr;
 192 #define MAX_SCANS  100          /* quite arbitrary limit */
 193   jpeg_scan_info scans[MAX_SCANS];
 194
 195   if ((fp = fopen(filename, "r")) == NULL) {
 196     fprintf(stderr, "Can't open scan definition file %s\n", filename);
 197     return FALSE;
 198   }
 199   scanptr = scans;
 200   scanno = 0;
 201
 202   while (read_scan_integer(fp, &val, &termchar)) {
 203     if (scanno >= MAX_SCANS) {
 204       fprintf(stderr, "Too many scans defined in file %s\n", filename);
 205       fclose(fp);
 206       return FALSE;
 207     }
 208     scanptr->component_index[0] = (int)val;
 209     ncomps = 1;
 210     while (termchar == ' ') {
 211       if (ncomps >= MAX_COMPS_IN_SCAN) {
 212         fprintf(stderr, "Too many components in one scan in file %s\n",
 213                 filename);
 214         fclose(fp);
 215         return FALSE;
 216       }
 217       if (!read_scan_integer(fp, &val, &termchar))
 218         goto bogus;
 219       scanptr->component_index[ncomps] = (int)val;
 220       ncomps++;
 221     }
 222     scanptr->comps_in_scan = ncomps;
 223     if (termchar == ':') {
 224       if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
 225         goto bogus;
 226       scanptr->Ss = (int)val;
 227       if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
 228         goto bogus;
 229       scanptr->Se = (int)val;
 230       if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
 231         goto bogus;
 232       scanptr->Ah = (int)val;
 233       if (!read_scan_integer(fp, &val, &termchar))
 234         goto bogus;
 235       scanptr->Al = (int)val;
 236     } else {
 237       /* set non-progressive parameters */
 238       scanptr->Ss = 0;
 239       scanptr->Se = DCTSIZE2 - 1;
 240       scanptr->Ah = 0;
 241       scanptr->Al = 0;
 242     }
 243     if (termchar != ';' && termchar != EOF) {
 244 bogus:
 245       fprintf(stderr, "Invalid scan entry format in file %s\n", filename);
 246       fclose(fp);
 247       return FALSE;
 248     }
 249     scanptr++, scanno++;
 250   }
 251
 252   if (termchar != EOF) {
 253     fprintf(stderr, "Non-numeric data in file %s\n", filename);
 254     fclose(fp);
 255     return FALSE;
 256   }
 257
 258   if (scanno > 0) {
 259     /* Stash completed scan list in cinfo structure.
 260      * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,
 261      * but if you want to compress multiple images you'd want JPOOL_PERMANENT.
 262      */
 263     scanptr = (jpeg_scan_info *)
 264       (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 265                                   scanno * sizeof(jpeg_scan_info));
 266     MEMCOPY(scanptr, scans, scanno * sizeof(jpeg_scan_info));
 267     cinfo->scan_info = scanptr;
 268     cinfo->num_scans = scanno;
 269   }
 270
 271   fclose(fp);
 272   return TRUE;
 273 }
 274
 275 #endif /* C_MULTISCAN_FILES_SUPPORTED */
 276
 277
 278 #if JPEG_LIB_VERSION < 70
 279 /* These are the sample quantization tables given in Annex K (Clause K.1) of
 280  * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
 281  * The spec says that the values given produce "good" quality, and
 282  * when divided by 2, "very good" quality.
 283  */
 284 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
 285   16,  11,  10,  16,  24,  40,  51,  61,
 286   12,  12,  14,  19,  26,  58,  60,  55,
 287   14,  13,  16,  24,  40,  57,  69,  56,
 288   14,  17,  22,  29,  51,  87,  80,  62,
 289   18,  22,  37,  56,  68, 109, 103,  77,
 290   24,  35,  55,  64,  81, 104, 113,  92,
 291   49,  64,  78,  87, 103, 121, 120, 101,
 292   72,  92,  95,  98, 112, 100, 103,  99
 293 };
 294 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
 295   17,  18,  24,  47,  99,  99,  99,  99,
 296   18,  21,  26,  66,  99,  99,  99,  99,
 297   24,  26,  56,  99,  99,  99,  99,  99,
 298   47,  66,  99,  99,  99,  99,  99,  99,
 299   99,  99,  99,  99,  99,  99,  99,  99,
 300   99,  99,  99,  99,  99,  99,  99,  99,
 301   99,  99,  99,  99,  99,  99,  99,  99,
 302   99,  99,  99,  99,  99,  99,  99,  99
 303 };
 304
 305
 306 LOCAL(void)
 307 jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
 308 {
 309   jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, q_scale_factor[0],
 310                        force_baseline);
 311   jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, q_scale_factor[1],
 312                        force_baseline);
 313 }
 314 #endif
 315
 316
 317 GLOBAL(boolean)
 318 set_quality_ratings(j_compress_ptr cinfo, char *arg, boolean force_baseline)
 319 /* Process a quality-ratings parameter string, of the form
 320  *     N[,N,...]
 321  * If there are more q-table slots than parameters, the last value is replicated.
 322  */
 323 {
 324   int val = 75;                 /* default value */
 325   int tblno;
 326   char ch;
 327
 328   for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
 329     if (*arg) {
 330       ch = ',';                 /* if not set by sscanf, will be ',' */
 331       if (sscanf(arg, "%d%c", &val, &ch) < 1)
 332         return FALSE;
 333       if (ch != ',')            /* syntax check */
 334         return FALSE;
 335       /* Convert user 0-100 rating to percentage scaling */
 336 #if JPEG_LIB_VERSION >= 70
 337       cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
 338 #else
 339       q_scale_factor[tblno] = jpeg_quality_scaling(val);
 340 #endif
 341       while (*arg && *arg++ != ','); /* advance to next segment of arg
 342                                         string */
 343     } else {
 344       /* reached end of parameter, set remaining factors to last value */
 345 #if JPEG_LIB_VERSION >= 70
 346       cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
 347 #else
 348       q_scale_factor[tblno] = jpeg_quality_scaling(val);
 349 #endif
 350     }
 351   }
 352   jpeg_default_qtables(cinfo, force_baseline);
 353   return TRUE;
 354 }
 355
 356
 357 GLOBAL(boolean)
 358 set_quant_slots(j_compress_ptr cinfo, char *arg)
 359 /* Process a quantization-table-selectors parameter string, of the form
 360  *     N[,N,...]
 361  * If there are more components than parameters, the last value is replicated.
 362  */
 363 {
 364   int val = 0;                  /* default table # */
 365   int ci;
 366   char ch;
 367
 368   for (ci = 0; ci < MAX_COMPONENTS; ci++) {
 369     if (*arg) {
 370       ch = ',';                 /* if not set by sscanf, will be ',' */
 371       if (sscanf(arg, "%d%c", &val, &ch) < 1)
 372         return FALSE;
 373       if (ch != ',')            /* syntax check */
 374         return FALSE;
 375       if (val < 0 || val >= NUM_QUANT_TBLS) {
 376         fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
 377                 NUM_QUANT_TBLS - 1);
 378         return FALSE;
 379       }
 380       cinfo->comp_info[ci].quant_tbl_no = val;
 381       while (*arg && *arg++ != ','); /* advance to next segment of arg
 382                                         string */
 383     } else {
 384       /* reached end of parameter, set remaining components to last table */
 385       cinfo->comp_info[ci].quant_tbl_no = val;
 386     }
 387   }
 388   return TRUE;
 389 }
 390
 391
 392 GLOBAL(boolean)
 393 set_sample_factors(j_compress_ptr cinfo, char *arg)
 394 /* Process a sample-factors parameter string, of the form
 395  *     HxV[,HxV,...]
 396  * If there are more components than parameters, "1x1" is assumed for the rest.
 397  */
 398 {
 399   int ci, val1, val2;
 400   char ch1, ch2;
 401
 402   for (ci = 0; ci < MAX_COMPONENTS; ci++) {
 403     if (*arg) {
 404       ch2 = ',';                /* if not set by sscanf, will be ',' */
 405       if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
 406         return FALSE;
 407       if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
 408         return FALSE;
 409       if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
 410         fprintf(stderr, "JPEG sampling factors must be 1..4\n");
 411         return FALSE;
 412       }
 413       cinfo->comp_info[ci].h_samp_factor = val1;
 414       cinfo->comp_info[ci].v_samp_factor = val2;
 415       while (*arg && *arg++ != ',');  /* advance to next segment of arg
 416                                          string */
 417     } else {
 418       /* reached end of parameter, set remaining components to 1x1 sampling */
 419       cinfo->comp_info[ci].h_samp_factor = 1;
 420       cinfo->comp_info[ci].v_samp_factor = 1;
 421     }
 422   }
 423   return TRUE;
 424 }