Updates libjpeg-turbo to 1.1.90 (r677)

third_party/libjpeg_turbo/rdjpgcom.c

 /*
  * rdjpgcom.c
  *
  * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2009 by Bill Allombert, Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
  * This file contains a very simple stand-alone application that displays
  * the text in COM (comment) markers in a JFIF file.
  * This may be useful as an example of the minimum logic needed to parse
  * JPEG markers.
  */
 
 #define JPEG_CJPEG_DJPEG        /* to get the command-line config symbols */
 #include "jinclude.h"           /* get auto-config symbols, <stdio.h> */
 
+#ifdef HAVE_LOCALE_H
+#include <locale.h>             /* Bill Allombert: use locale for isprint */
+#endif
 #include <ctype.h>              /* to declare isupper(), tolower() */
 #ifdef USE_SETMODE
 #include <fcntl.h>              /* to declare setmode()'s parameter macros */
 /* If you have setmode() but not <io.h>, just delete this line: */
 #include <io.h>                 /* to declare setmode() */
 #endif
 
 #ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
 #ifdef __MWERKS__
 #include <SIOUX.h>              /* Metrowerks needs this */
@@ skipping 184 matching lines @@
 }
 
 
 /*
  * Process a COM marker.
  * We want to print out the marker contents as legible text;
  * we must guard against non-text junk and varying newline representations.
  */
 
 static void
-process_COM (void)
+process_COM (int raw)
 {
   unsigned int length;
   int ch;
   int lastch = 0;
 
+  /* Bill Allombert: set locale properly for isprint */
+#ifdef HAVE_LOCALE_H
+  setlocale(LC_CTYPE, "");
+#endif
+
   /* Get the marker parameter length count */
   length = read_2_bytes();
   /* Length includes itself, so must be at least 2 */
   if (length < 2)
     ERREXIT("Erroneous JPEG marker length");
   length -= 2;
 
   while (length > 0) {
     ch = read_1_byte();
+    if (raw) {
+      putc(ch, stdout);
     /* Emit the character in a readable form.
      * Nonprintables are converted to \nnn form,
      * while \ is converted to \\.
      * Newlines in CR, CR/LF, or LF form will be printed as one newline.
      */
-    if (ch == '\r') {
+    } else if (ch == '\r') {
       printf("\n");
     } else if (ch == '\n') {
       if (lastch != '\r')
         printf("\n");
     } else if (ch == '\\') {
       printf("\\\\");
     } else if (isprint(ch)) {
       putc(ch, stdout);
     } else {
       printf("\\%03o", ch);
     }
     lastch = ch;
     length--;
   }
   printf("\n");
+
+  /* Bill Allombert: revert to C locale */
+#ifdef HAVE_LOCALE_H
+  setlocale(LC_CTYPE, "C");
+#endif
 }
 
 
 /*
  * Process a SOFn marker.
  * This code is only needed if you want to know the image dimensions...
  */
 
 static void
 process_SOFn (int marker)
@@ skipping 47 matching lines @@
  * Parse the marker stream until SOS or EOI is seen;
  * display any COM markers.
  * While the companion program wrjpgcom will always insert COM markers before
  * SOFn, other implementations might not, so we scan to SOS before stopping.
  * If we were only interested in the image dimensions, we would stop at SOFn.
  * (Conversely, if we only cared about COM markers, there would be no need
  * for special code to handle SOFn; we could treat it like other markers.)
  */
 
 static int
-scan_JPEG_header (int verbose)
+scan_JPEG_header (int verbose, int raw)
 {
   int marker;
 
   /* Expect SOI at start of file */
   if (first_marker() != M_SOI)
     ERREXIT("Expected SOI marker first");
 
   /* Scan miscellaneous markers until we reach SOS. */
   for (;;) {
     marker = next_marker();
@@ skipping 20 matching lines @@
         skip_variable();
       break;
 
     case M_SOS:                 /* stop before hitting compressed data */
       return marker;
 
     case M_EOI:                 /* in case it's a tables-only JPEG stream */
       return marker;
 
     case M_COM:
-      process_COM();
+      process_COM(raw);
       break;
 
     case M_APP12:
       /* Some digital camera makers put useful textual information into
        * APP12 markers, so we print those out too when in -verbose mode.
        */
       if (verbose) {
         printf("APP12 contains:\n");
-        process_COM();
+        process_COM(raw);
       } else
         skip_variable();
       break;
 
     default:                    /* Anything else just gets skipped */
       skip_variable();          /* we assume it has a parameter count... */
       break;
     }
   } /* end loop */
 }
 
 
 /* Command line parsing code */
 
 static const char * progname;   /* program name for error messages */
 
 
 static void
 usage (void)
 /* complain about bad command line */
 {
   fprintf(stderr, "rdjpgcom displays any textual comments in a JPEG file.\n");
 
   fprintf(stderr, "Usage: %s [switches] [inputfile]\n", progname);
 
   fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -raw        Display non-printable characters in comments (unsafe)\n");
   fprintf(stderr, "  -verbose    Also display dimensions of JPEG image\n");
 
   exit(EXIT_FAILURE);
 }
 
 
 static int
 keymatch (char * arg, const char * keyword, int minchars)
 /* Case-insensitive matching of (possibly abbreviated) keyword switches. */
 /* keyword is the constant keyword (must be lower case already), */
@@ skipping 20 matching lines @@
 
 /*
  * The main program.
  */
 
 int
 main (int argc, char **argv)
 {
   int argn;
   char * arg;
-  int verbose = 0;
+  int verbose = 0, raw = 0;
 
   /* On Mac, fetch a command line. */
 #ifdef USE_CCOMMAND
   argc = ccommand(&argv);
 #endif
 
   progname = argv[0];
   if (progname == NULL || progname[0] == 0)
     progname = "rdjpgcom";      /* in case C library doesn't provide it */
 
   /* Parse switches, if any */
   for (argn = 1; argn < argc; argn++) {
     arg = argv[argn];
     if (arg[0] != '-')
       break;                    /* not switch, must be file name */
     arg++;                      /* advance over '-' */
     if (keymatch(arg, "verbose", 1)) {
       verbose++;
+    } else if (keymatch(arg, "raw", 1)) {
+      raw = 1;
     } else
       usage();
   }
 
   /* Open the input file. */
   /* Unix style: expect zero or one file name */
   if (argn < argc-1) {
     fprintf(stderr, "%s: only one input file\n", progname);
     usage();
   }
@@ skipping 11 matching lines @@
     if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
       fprintf(stderr, "%s: can't open stdin\n", progname);
       exit(EXIT_FAILURE);
     }
 #else
     infile = stdin;
 #endif
   }
 
   /* Scan the JPEG headers. */
-  (void) scan_JPEG_header(verbose);
+  (void) scan_JPEG_header(verbose, raw);
 
   /* All done. */
   exit(EXIT_SUCCESS);
   return 0;                     /* suppress no-return-value warnings */
 }