/*******************************************************************

 * JPEGoptim

 * Copyright (c) Timo Kokkonen, 1996-2026.

 * All Rights Reserved.

 *

 * requires libjpeg (Independent JPEG Group's JPEG software

 *                     release 6a or later...)

 *

 * SPDX-License-Identifier: GPL-3.0-or-later

 *

 * This file is part of JPEGoptim.

 *

 * JPEGoptim is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * JPEGoptim is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with JPEGoptim. If not, see <https://www.gnu.org/licenses/>.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#if HAVE_DIRENT_H

#include <dirent.h>

#endif

#if HAVE_FCNTL_H

#include <fcntl.h>

#endif

#if HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#if HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#if HAVE_SYS_WAIT_H

#include <sys/wait.h>

#endif

#if HAVE_GETOPT_H && HAVE_GETOPT_LONG

#include <getopt.h>

#else

#include "getopt.h"

#endif

#include <signal.h>

#include <string.h>

#include <limits.h>

#include <jpeglib.h>

#include <jerror.h>

#include <setjmp.h>

#include <time.h>

#include <math.h>

#include "jpegmarker.h"

#include "jpegoptim.h"

#define VERSION "1.5.7beta"

#define COPYRIGHT  "Copyright (C) 1996-2026, Timo Kokkonen"

#if HAVE_WAIT && HAVE_FORK

#define PARALLEL_PROCESSING 1

#define MAX_WORKERS 256

#include <poll.h>

#include <errno.h>

#endif

#define IN_BUF_SIZE (256 * 1024)

struct my_error_mgr {

  struct jpeg_error_mgr pub;

  jmp_buf setjmp_buffer;

  int     jump_set;

};

typedef struct my_error_mgr * my_error_ptr;

#ifdef PARALLEL_PROCESSING

struct worker {

  pid_t pid;

  int   read_pipe;

};

struct worker *workers;

int worker_count = 0;

#endif

int verbose_mode = 0;

int quiet_mode = 0;

int preserve_mode = 0;

int preserve_perms = 0;

int overwrite_mode = 0;

int retry_mode = 0;

int totals_mode = 0;

int stdin_mode = 0;

int stdout_mode = 0;

int noaction = 0;

int quality = -1;

int dest = 0;

int force = 0;

int save_extra = 0;

int save_exif = 1;

int save_iptc = 1;

int save_com = 1;

int save_icc = 1;

int save_xmp = 1;

int save_adobe = 0;

int save_jfxx = 0;

int save_jfif = 1;

int strip_none = 0;

double threshold = -1.0;

int csv = 0;

int auto_mode = 0;

int all_normal = 0;

int all_progressive = 0;

int target_size = 0;

#ifdef HAVE_ARITH_CODE

int arith_mode = -1;

#endif

int max_workers = 1;

int nofix_mode = 0;

int files_stdin = 0;

FILE *files_from = NULL;

int compress_err_count = 0;

int decompress_err_count = 0;

int global_error_counter = 0;

char last_error[JMSG_LENGTH_MAX+1];

FILE *jpeg_log_fh;

long average_count = 0;

double average_rate = 0.0;

double total_save = 0.0;

const struct option long_options[] = {

#ifdef HAVE_ARITH_CODE

  { "all-arith",          0, &arith_mode,          1 },

  { "all-huffman",        0, &arith_mode,          0 },

#endif

  { "auto-mode",          0, &auto_mode,          1 },

  { "all-normal",         0, &all_normal,          1 },

  { "all-progressive",    0, &all_progressive,     1 },

  { "csv",                0, 0,                    'b' },

  { "dest",               1, 0,                    'd' },

  { "files-stdin",        0, &files_stdin,         1 },

  { "files-from",         1, 0,                    'F' },

  { "force",              0, 0,                    'f' },

  { "help",               0, 0,                    'h' },

  { "keep-adobe",         0, &save_adobe,          1 },

  { "keep-all",           0, &strip_none,          1 },

  { "keep-com",           0, &save_com,            1 },

  { "keep-exif",          0, &save_exif,           1 },

  { "keep-iptc",          0, &save_iptc,           1 },

  { "keep-icc",           0, &save_icc,            1 },

  { "keep-jfif",          0, &save_jfif,           1 },

  { "keep-jfxx",          0, &save_jfxx,           1 },

  { "keep-xmp",           0, &save_xmp,            1 },

  { "max",                1, 0,                    'm' },

  { "noaction",           0, 0,                    'n' },

  { "nofix",              0, &nofix_mode,          1 },

  { "overwrite",          0, 0,                    'o' },

  { "preserve",           0, 0,                    'p' },

  { "preserve-perms",     0, 0,                    'P' },

  { "quiet",              0, 0,                    'q' },

  { "retry",              0, 0,                    'r' },

  { "save-extra",         0, &save_extra,          1 },

  { "size",               1, 0,                    'S' },

  { "stdin",              0, &stdin_mode,          1 },

  { "stdout",             0, &stdout_mode,         1 },

  { "strip-all",          0, 0,                    's' },

  { "strip-none",         0, &strip_none,          1 },

  { "strip-com",          0, &save_com,            0 },

  { "strip-exif",         0, &save_exif,           0 },

  { "strip-iptc",         0, &save_iptc,           0 },

  { "strip-icc",          0, &save_icc,            0 },

  { "strip-xmp",          0, &save_xmp,            0 },

  { "strip-jfif",         0, &save_jfif,           0 },

  { "strip-jfxx",         0, &save_jfxx,           0 },

  { "strip-adobe",        0, &save_adobe,          0 },

  { "threshold",          1, 0,                    'T' },

  { "totals",             0, 0,                    't' },

  { "verbose",            0, 0,                    'v' },

  { "version",            0, 0,                    'V' },

#ifdef PARALLEL_PROCESSING

  { "workers",            1, 0,                    'w' },

#endif

  { 0, 0, 0, 0 }

};

/*****************************************************************/

void free_line_buf(JSAMPARRAY volatile *buf, unsigned int lines)

{

  if (*buf == NULL)

    return;

  for (unsigned int i = 0; i < lines; i++) {

    if ((*buf)[i])

      free((*buf)[i]);

  }

  free(*buf);

  *buf = NULL;

}

METHODDEF(void) my_error_exit (j_common_ptr cinfo)

{

  my_error_ptr myerr = (my_error_ptr)cinfo->err;

  (*cinfo->err->output_message)(cinfo);

  if (myerr->jump_set)

    longjmp(myerr->setjmp_buffer, 1);

  else

    fatal("fatal error");

}

METHODDEF(void) my_output_message (j_common_ptr cinfo)

{

  char buffer[JMSG_LENGTH_MAX+1];

  (*cinfo->err->format_message)((j_common_ptr)cinfo, buffer);

  buffer[sizeof(buffer) - 1] = 0;

  if (verbose_mode)

    fprintf(jpeg_log_fh, " (%s) ", buffer);

  global_error_counter++;

  strncopy(last_error, buffer, sizeof(last_error));

}

void print_usage(void)

{

  fprintf(stdout,PROGRAMNAME " v" VERSION "  " COPYRIGHT "\n");

  fprintf(stdout,

    "Usage: " PROGRAMNAME " [options] <filenames> \n\n"

    "  -d<path>, --dest=<path>\n"

    "                    specify alternative destination directory for \n"

    "                    optimized files (default is to overwrite originals)\n"

    "  -f, --force       force optimization\n"

    "  -h, --help        display this help and exit\n"

    "  -m<quality>, --max=<quality>\n"

    "                    set maximum image quality factor (disables lossless\n"

    "                    optimization mode, which is by default on)\n"

    "                    Valid quality values: 0 - 100\n"

    "  -n, --noaction    don't really optimize files, just print results\n"

    "  -S<size>, --size=<size>\n"

    "                    Try to optimize file to given size (disables lossless\n"

    "                    optimization mode). Target size is specified either in\n"

    "                    kilo bytes (1 - n) or as percentage (1%% - 99%%)\n"

    "  -T<threshold>, --threshold=<threshold>\n"

    "                    keep old file if the gain is below a threshold (%%)\n"

#ifdef PARALLEL_PROCESSING

    "  -w<max>, --workers=<max>\n"

    "                    set maximum number of parallel threads (default is 1)\n"

#endif

    "  -b, --csv         print progress info in CSV format\n"

    "  -o, --overwrite   overwrite target file even if it exists (meaningful\n"

    "                    only when used with -d, --dest option)\n"

    "  -p, --preserve    preserve file timestamps\n"

    "  -P, --preserve-perms\n"

    "                    preserve original file permissions by overwriting it\n"

    "  -q, --quiet       quiet mode\n"

    "  -r, --retry       try (recursively) optimize until file size does not change anymore\n"

    "  -t, --totals      print totals after processing all files\n"

    "  -v, --verbose     enable verbose mode (positively chatty)\n"

    "  -V, --version     print program version\n\n"

    "  -s, --strip-all   strip all markers from output file\n"

    "  --strip-none      do not strip any markers\n"

    "  --strip-adobe     strip Adobe (APP14) markers from output file\n"

    "  --strip-com       strip Comment markers from output file\n"

    "  --strip-exif      strip Exif markers from output file\n"

    "  --strip-iptc      strip IPTC/Photoshop (APP13) markers from output file\n"

    "  --strip-icc       strip ICC profile markers from output file\n"

    "  --strip-jfif      strip JFIF markers from output file\n"

    "  --strip-jfxx      strip JFXX (JFIF Extension) markers from output file\n"

    "  --strip-xmp       strip XMP markers markers from output file\n"

    "\n"

    "  --keep-all        do not strip any markers (same as --strip-none)\n"

    "  --keep-adobe      preserve any Adobe (APP14) markers\n"

    "  --keep-com        preserve any Comment markers\n"

    "  --keep-exif       preserve any Exif markers\n"

    "  --keep-iptc       preserve any IPTC/Photoshop (APP13) markers\n"

    "  --keep-icc        preserve any ICC profile markers\n"

    "  --keep-jfif       preserve any JFIF markers\n"

    "  --keep-jfxx       preserve any JFXX (JFIF Extension) markers\n"

    "  --keep-xmp        preserve any XMP markers markers\n"

    "\n"

    "  --all-normal      force all output files to be non-progressive\n"

    "  --all-progressive force all output files to be progressive\n"

    "  --auto-mode       select normal or progressive based on which produces\n"

    "                    smaller output file\n"

#ifdef HAVE_ARITH_CODE

    "  --all-arith       force all output files to use arithmetic coding\n"

    "  --all-huffman     force all output files to use Huffman coding\n"

#endif

    "  --stdout          send output to standard output (instead of a file)\n"

    "  --stdin           read input from standard input (instead of a file)\n"

    "  --files-stdin     Read names of files to process from stdin\n"

    "  --files-from=FILE Read names of files to process from a file\n"

    "  --nofix           skip processing of input files if they contain any errors\n"

    "  --save-extra      preserve extraneous data after the end of image\n"

    "\n\n");

}

void print_version()

{

  struct jpeg_error_mgr jerr;

#ifdef  __DATE__

  printf(PROGRAMNAME " v%s  %s (%s)\n",VERSION, HOST_TYPE, __DATE__);

#else

  printf(PROGRAMNAME " v%s  %s\n", VERSION, HOST_TYPE);

#endif

  printf(COPYRIGHT "\n\n");

  printf("This program comes with ABSOLUTELY NO WARRANTY. This is free software,\n"

    "and you are welcome to redistribute it under certain conditions.\n"

    "See the GNU General Public License for more details.\n\n");

  if (!jpeg_std_error(&jerr))

    fatal("jpeg_std_error() failed");

  printf("\nlibjpeg version: %s\n%s\n",

    jerr.jpeg_message_table[JMSG_VERSION],

    jerr.jpeg_message_table[JMSG_COPYRIGHT]);

}

void parse_arguments(int argc, char **argv, char *dest_path, size_t dest_path_len)

{

  int opt_index;

  int i, c;

  while(1) {

    opt_index=0;

    if ((c = getopt_long(argc,argv,"d:hm:nstqvfVpProT:S:bw:",

            long_options, &opt_index)) == -1)

      break;

    switch (c) {

    case 'm':

            {

        int tmpvar;

        if (sscanf(optarg,"%d",&tmpvar) == 1) {

          quality=tmpvar;

          if (quality < 0) quality=0;

          if (quality > 100) quality=100;

        }

        else

          fatal("invalid argument for -m, --max");

      }

      break;

    case 'd':

            {

        /* Use the allocating form of realpath(), as a caller

           supplied buffer would need to be at least PATH_MAX

           bytes, which can be larger than MAXPATHLEN... */

        char *dpath = realpath(optarg, NULL);

        if (!dpath)

          fatal("invalid destination directory: %s", optarg);

        if (!is_directory(dpath))

          fatal("destination not a directory: %s", dpath);

        if (strlen(dpath) + strlen(DIR_SEPARATOR_S) >= dest_path_len)

          fatal("destination directory path too long: %s", optarg);

        strncopy(dest_path, dpath, dest_path_len);

        free(dpath);

        strncatenate(dest_path, DIR_SEPARATOR_S, dest_path_len);

        if (verbose_mode)

          fprintf(stderr,"Destination directory: %s\n",dest_path);

        dest=1;

      }

      break;

    case 'v':

      verbose_mode++;

      break;

    case 'h':

      print_usage();

      exit(0);

      break;

    case 'q':

      quiet_mode=1;

      break;

    case 'r':

      retry_mode=1;

      break;

    case 't':

      totals_mode=1;

      break;

    case 'n':

      noaction=1;

      break;

    case 'f':

      force=1;

      break;

    case 'b':

      csv=1;

      quiet_mode=1;

      break;

    case 'V':

      print_version();

      exit(0);

      break;

    case 'o':

      overwrite_mode=1;

      break;

    case 'p':

      preserve_mode=1;

      break;

    case 'P':

      preserve_perms=1;

      break;

    case 's':

      save_exif=0;

      save_iptc=0;

      save_com=0;

      save_icc=0;

      save_xmp=0;

      save_adobe=0;

      save_jfif=0;

      save_jfxx=0;

      break;

    case 'T':

            {

        double tmpvar;

        if (sscanf(optarg,"%lf", &tmpvar) == 1) {

          threshold=tmpvar;

          if (threshold < 0) threshold=0;

          if (threshold > 100) threshold=100;

        }

        else fatal("invalid argument for -T, --threshold");

      }

      break;

    case 'S':

            {

        char *endp = NULL;

        long tmpvar = strtol(optarg, &endp, 10);

        if (endp == optarg || tmpvar <= 0)

          fatal("invalid argument for -S, --size: %s", optarg);

        if (endp[0] == '%' && endp[1] == 0) {

          /* Target size given as percentage (1% - 99%) */

          if (tmpvar >= 100)

            fatal("invalid percentage for -S, --size: %s", optarg);

          target_size = -tmpvar;

        } else if (endp[0] == 0) {

          /* Target size given in kilobytes */

          if (tmpvar > INT_MAX)

            fatal("invalid argument for -S, --size: %s", optarg);

          target_size = tmpvar;

        } else {

          fatal("invalid argument for -S, --size: %s", optarg);

        }

        quality=100;

      }

      break;

#ifdef PARALLEL_PROCESSING

    case 'w':

            {

        int tmpvar;

        if (sscanf(optarg, "%d", &tmpvar) == 1) {

          if (tmpvar > 0 && tmpvar <= MAX_WORKERS)

            max_workers = tmpvar;

        }

        else fatal("invalid argument for -w, --workers");

      }

      break;

#endif

    case 'F':

            {

        if (optarg[0] == '-' && optarg[1] == 0) {

          files_stdin = 1;

          break;

        }

        if (!is_file(optarg, NULL))

          fatal("argument for --files-from must be a file");

        if ((files_from = fopen(optarg, "r")) == NULL)

          fatal("cannot open file: '%s'", optarg);

      }

      break;

    case '?':

      exit(1);

    }

  }

  /* check for '-' option indicating input is from stdin... */

  i = optind;

  while (argv[i]) {

    if (argv[i][0]=='-' && argv[i][1]==0)

      stdin_mode=1;

    i++;

  }

  if (stdin_mode)

    stdout_mode=1;

  if (files_stdin)

    files_from = stdin;

  if (stdin_mode && files_from == stdin)

    fatal("cannot specify both --stdin and --files-stdin");

#ifdef PARALLEL_PROCESSING

  if (stdout_mode && max_workers > 1) {

    /* Parallel workers would write to stdout concurrently,

       interleaving (corrupting) the output stream... */

    warn("--stdout is incompatible with parallel workers, using only one worker");

    max_workers = 1;

  }

#endif

  if (all_normal && all_progressive)

    fatal("cannot specify both --all-normal and --all-progressive");

  if (auto_mode && (all_normal || all_progressive))

    fatal("cannot specify --all-normal or --all-progressive if using --auto-mode");

}

void own_signal_handler(int a)

{

  if (verbose_mode > 1)

    fprintf(stderr,PROGRAMNAME ": died from signal: %d\n",a);

  exit(2);

}

void write_markers(struct jpeg_decompress_struct *dinfo,

    struct jpeg_compress_struct *cinfo)

{

  jpeg_saved_marker_ptr mrk;

  int write_marker;

  const char *s_name;

  if (!cinfo || !dinfo)

    fatal("invalid call to write_markers()");

  mrk=dinfo->marker_list;

  while (mrk) {

    write_marker = 0;

    s_name = jpeg_special_marker_name(mrk);

    /* Check for markers to save... */

    if (save_com && mrk->marker == JPEG_COM)

      write_marker++;

    if (save_iptc && !strncmp(s_name, "IPTC", 5))

      write_marker++;

    if (save_exif && !strncmp(s_name, "Exif", 5))

      write_marker++;

    if (save_icc && !strncmp(s_name, "ICC", 4))

      write_marker++;

    if (save_xmp && !strncmp(s_name, "XMP", 4))

      write_marker++;

    if (save_jfxx && !strncmp(s_name, "JFXX", 5))

      write_marker++;

    if (save_adobe && !strncmp(s_name, "Adobe", 6))

      write_marker++;

    if (strip_none)

      write_marker++;

    /* libjpeg emits some markers automatically so skip these to avoid duplicates... */

    if (!strncmp(s_name, "JFIF", 5))

      write_marker=0;

    if (verbose_mode > 2)

      fprintf(jpeg_log_fh, " (Marker %s [%s]: %s)", jpeg_marker_name(mrk->marker),

        s_name, (write_marker ? "Keep" : "Discard"));

    if (write_marker)

      jpeg_write_marker(cinfo, mrk->marker, mrk->data, mrk->data_length);

    mrk=mrk->next;

  }

}

unsigned int parse_markers(const struct jpeg_decompress_struct *dinfo,

      char *str, unsigned int str_size, unsigned int *markers_total_size)

{

  jpeg_saved_marker_ptr m;

  unsigned int count = 0;

  char *seen;

  size_t marker_types = jpeg_special_marker_types_count();

  int com_seen = 0;

  int special;

  if ((seen = calloc(marker_types, 1)) == NULL)

    fatal("not enough of memory");

  str[0] = 0;

  *markers_total_size = 0;

  m = dinfo->marker_list;

  while (m) {

    count++;

    *markers_total_size += m->data_length;

    if ((special = jpeg_special_marker(m)) >= 0) {

      if (!seen[special])

        str_add_list(str, str_size, jpeg_special_marker_types[special].name, ",");

      seen[special]++;

    }

    if (m->marker == JPEG_COM && !com_seen) {

      str_add_list(str, str_size, "COM", ",");

      com_seen = 1;

    }

    m = m->next;

  }

  free(seen);

  return count;

}

int optimize(FILE *log_fh, const char *filename, const char *newname,

  const char *tmpdir, struct stat *file_stat,

  double *rate, double *saved,

  int auto_mode, int all_normal, int all_progressive)

{

  FILE *infile = NULL;

  FILE *outfile = NULL;

  const char *outfname = NULL;

  char tmpfilename[MAXPATHLEN];

  struct jpeg_decompress_struct dinfo;

  struct jpeg_compress_struct cinfo;

  struct my_error_mgr jcerr, jderr;

  /* These buffers are (re)allocated between setjmp() and a possible

     longjmp() from the libjpeg error handlers, and then freed at

     exit_point after the jump. They must be volatile-qualified, as

     otherwise their values are indeterminate after longjmp()

     (C11 7.13.2.1), risking double-free or leak. */

  JSAMPARRAY volatile buf = NULL;

  unsigned char * volatile outbuffer = NULL;

  unsigned char * volatile inbuffer = NULL;

  unsigned char * volatile tmpbuffer = NULL;

  unsigned char * volatile extrabuffer = NULL;

  size_t outbuffersize = 0;

  size_t inbuffersize = 0;

  size_t inbufferused = 0;

  size_t tmpbuffersize = 0;

  size_t extrabuffersize = 0;

  int write_error = 0;

  jvirt_barray_ptr *coef_arrays = NULL;

  char marker_str[256];

  unsigned int marker_in_count, marker_in_size;

  long in_image_size = 0;

  long insize = 0, outsize = 0, lastsize = 0;

  int oldquality, searchdone;

  double ratio;

  size_t last_retry_size = 0;

  int retry_count = 0;

  int retry = 0;

  int res = -1;

  jpeg_log_fh = log_fh;

  /* Initialize decompression object */

  dinfo.err = jpeg_std_error(&jderr.pub);

  jpeg_create_decompress(&dinfo);

  jderr.pub.error_exit=my_error_exit;

  jderr.pub.output_message=my_output_message;

  jderr.jump_set = 0;

  /* Initialize compression object */

  cinfo.err = jpeg_std_error(&jcerr.pub);

  jpeg_create_compress(&cinfo);

  jcerr.pub.error_exit=my_error_exit;

  jcerr.pub.output_message=my_output_message;

  jcerr.jump_set = 0;

  if (rate)

    *rate = 0.0;

  if (saved)

    *saved = 0.0;

  if (filename) {

    if ((infile = fopen(filename, "rb")) == NULL) {

      warn("cannot open file: %s", filename);

      res = 1;

      goto exit_point;

    }

  } else {

    infile = stdin;

    set_filemode_binary(infile);

  }

retry_point:

  if (setjmp(jderr.setjmp_buffer)) {

    /* Error handler for decompress */

  abort_decompress:

    jpeg_abort_decompress(&dinfo);

    fclose(infile);

    free_line_buf(&buf, dinfo.output_height);

    if (!quiet_mode || csv)

      fprintf(log_fh,csv ? ",,,,,error\n" : " [ERROR]\n");

    jderr.jump_set=0;

    res = 1;

    goto exit_point;

  } else {

    jderr.jump_set=1;

  }

  /* Prepare to decompress */

  if (!retry) {

    if (!quiet_mode || csv) {

      if (csv) {

        fprint_csv_field(log_fh, (filename ? filename : "stdin"));

        fputc(',', log_fh);

      } else {

        fprintf(log_fh, "%s ", (filename ? filename : "stdin"));

      }

      fflush(log_fh);

    }

    if (stdin_mode || stdout_mode) {

      inbuffersize = IN_BUF_SIZE;

    } else {

      long fsize = file_size(infile);

      if (fsize < 0)

        fatal("failed to stat() input file: %s", filename);

      inbuffersize = (fsize < IN_BUF_SIZE ? IN_BUF_SIZE : (size_t)fsize);

    }

    if (inbuffer)

      free(inbuffer);

    if (!(inbuffer=calloc(inbuffersize, 1)))

      fatal("not enough memory");

  }

  global_error_counter=0;

  jpeg_save_markers(&dinfo, JPEG_COM, 0xffff);

  for (int i = 0; i < 16; i++) {

    jpeg_save_markers(&dinfo, JPEG_APP0 + i, 0xffff);

  }

  if (!retry) {

    jpeg_custom_src(&dinfo, infile, &inbuffer, &inbuffersize, &inbufferused, IN_BUF_SIZE);

  } else {

    /* Only the --retry shrink loop (retry == 2) deliberately re-compresses

       its own previous output. The lossless fallback (retry == 1) and the

       auto-mode alternate pass (retry == 3) must start from the original

       image, as recompressing already lossy-compressed data would cause

       generation loss. */

    if (retry == 2)

      jpeg_custom_mem_src(&dinfo, tmpbuffer, tmpbuffersize);

    else

      jpeg_custom_mem_src(&dinfo, inbuffer, inbufferused);

  }

  jpeg_read_header(&dinfo, TRUE);

  /* Check for known (Exif, IPTC, ICC , XMP, ...) markers */

  marker_in_count = parse_markers(&dinfo, marker_str, sizeof(marker_str),

          &marker_in_size);

  if (!retry) {

    if (verbose_mode > 1) {

      fprintf(log_fh,"%d markers found in input file (total size %d bytes)\n",

        marker_in_count,marker_in_size);

      fprintf(log_fh,"coding: %s\n", (dinfo.arith_code == TRUE ? "Arithmetic" : "Huffman"));

    }

    if (!quiet_mode || csv) {

      fprintf(log_fh,csv ? "%dx%d,%dbit,%c," : "%dx%d %dbit %c ",(int)dinfo.image_width,

        (int)dinfo.image_height,(int)dinfo.num_components*8,

        (dinfo.progressive_mode?'P':'N'));

      if (!csv)

        fprintf(log_fh,"%s",marker_str);

      fflush(log_fh);

    }

  }

  /* Decompress the image */

  if (quality >= 0 && retry != 1) {

    jpeg_start_decompress(&dinfo);

    /* Allocate line buffer to store the decompressed image */

    if (!(buf = calloc(dinfo.output_height, sizeof(JSAMPROW))))

      fatal("not enough memory");

    for (int i = 0; i < dinfo.output_height; i++) {

      if (!(buf[i]=calloc((size_t)dinfo.output_width * dinfo.out_color_components,

              sizeof(JSAMPLE))))

        fatal("not enough memory");

    }

    while (dinfo.output_scanline < dinfo.output_height) {

      jpeg_read_scanlines(&dinfo,&buf[dinfo.output_scanline],

          dinfo.output_height-dinfo.output_scanline);

    }

  } else {

    coef_arrays = jpeg_read_coefficients(&dinfo);

    if (!coef_arrays) {

      if (!quiet_mode)

        fprintf(log_fh, " (failed to read coefficients) ");

      goto abort_decompress;

    }

  }

  if (!retry) {

    in_image_size = inbufferused - dinfo.src->bytes_in_buffer;

    if(verbose_mode > 2)

      fprintf(log_fh, " (input image size: %ld (%ld))", in_image_size, inbufferused);

    if (stdin_mode) {

      insize = in_image_size;

    } else {

      if ((insize = file_size(infile)) < 0)

        fatal("failed to stat() input file: %s", filename);

      if (in_image_size > 0 && in_image_size < insize) {

        if (!quiet_mode)

          fprintf(log_fh, " (%ld bytes extraneous data found after end of image) ",

            insize - in_image_size);

        if (nofix_mode)

          global_error_counter++;

        if (save_extra) {

          extrabuffersize = insize - in_image_size;

          if (extrabuffer)

            free(extrabuffer);

          if (!(extrabuffer = calloc(extrabuffersize, 1)))

            fatal("not enough memory");

          if (fseek(infile, in_image_size, SEEK_SET))

            fatal("failed to seek input file");

          if (fread(extrabuffer, extrabuffersize, 1, infile) != 1)

            fatal("failed to read inputfile");

        }

      }

    }

    if (!quiet_mode) {

      fprintf(log_fh,(global_error_counter==0 ? " [OK] " : " [WARNING] "));

      fflush(log_fh);

    }

    if (nofix_mode && global_error_counter != 0) {

      /* Skip files containing any errors (or warnings) */

      goto abort_decompress;

    }

    if (dest && !noaction) {

      if (file_exists(newname) && !overwrite_mode) {

        if (!quiet_mode)

          fprintf(log_fh, " (target file already exists) ");

        goto abort_decompress;

      }

    }

  }

  /* Prepare to compress... */

  if (setjmp(jcerr.setjmp_buffer)) {

    /* Error handler for compress failures */

    if (!quiet_mode)

      fprintf(log_fh," [Compress ERROR: %s]\n",last_error);

    jpeg_abort_compress(&cinfo);

    jpeg_abort_decompress(&dinfo);

    fclose(infile);

    free_line_buf(&buf, dinfo.output_height);

    jcerr.jump_set=0;

    res = 2;

    goto exit_point;

  } else {

    jcerr.jump_set=1;

  }

  lastsize = 0;

  searchdone = 0;

  if (!retry) {

    oldquality = 200;

    if (target_size != 0) {

      /* Always start with quality 100 if -S option specified... */

      quality = 100;

    }

  }

binary_search_loop:

  /* Allocate memory buffer that should be large enough to store the output JPEG... */

  if (outbuffer)

    free(outbuffer);

  outbuffersize = insize + 32768;

  if (!(outbuffer=calloc(outbuffersize, 1)))

    fatal("not enough memory");

  /* setup custom "destination manager" for libjpeg to write to our buffer */

  jpeg_memory_dest(&cinfo, &outbuffer, &outbuffersize, 65536);

  if (quality >= 0 && retry != 1) {

    /* Lossy "optimization" ... */

    cinfo.in_color_space=dinfo.out_color_space;

    cinfo.input_components=dinfo.output_components;

    cinfo.image_width=dinfo.image_width;

    cinfo.image_height=dinfo.image_height;

    jpeg_set_defaults(&cinfo);

    jpeg_set_quality(&cinfo,quality,TRUE);

#ifdef HAVE_JINT_DC_SCAN_OPT_MODE

    if (jpeg_c_int_param_supported(&cinfo, JINT_DC_SCAN_OPT_MODE))

      jpeg_c_set_int_param(&cinfo, JINT_DC_SCAN_OPT_MODE, 1);

#endif

    if (all_normal || (!dinfo.progressive_mode && !all_progressive)) {

      /* Explicitly disable progressive mode. */

      cinfo.scan_info = NULL;

      cinfo.num_scans = 0;

    } else if (all_progressive || dinfo.progressive_mode) {

      /* Enable progressive mode. */

      jpeg_simple_progression(&cinfo);

    }

    cinfo.optimize_coding = TRUE;

#ifdef HAVE_ARITH_CODE

    if (arith_mode >= 0)

      cinfo.arith_code = (arith_mode > 0 ? TRUE : FALSE);

#endif

    if (dinfo.saw_JFIF_marker && (save_jfif || strip_none)) {

      cinfo.write_JFIF_header = TRUE;

    } else {

      cinfo.write_JFIF_header = FALSE;

    }

    if (dinfo.saw_Adobe_marker && (save_adobe || strip_none)) {