/*

 * Copyright (C)2009-2020 D. R. Commander.  All Rights Reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * - Redistributions of source code must retain the above copyright notice,

 *   this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright notice,

 *   this list of conditions and the following disclaimer in the documentation

 *   and/or other materials provided with the distribution.

 * - Neither the name of the libjpeg-turbo Project nor the names of its

 *   contributors may be used to endorse or promote products derived from this

 *   software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/* TurboJPEG/LJT:  this implements the TurboJPEG API using libjpeg or

   libjpeg-turbo */

#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <ctype.h></ctype.h>

#include <jinclude.h></jinclude.h>

#define JPEG_INTERNALS

#include <jpeglib.h></jpeglib.h>

#include <jerror.h></jerror.h>

#include <setjmp.h></setjmp.h>

#include <errno.h></errno.h>

#include "./turbojpeg.h"

#include "./tjutil.h"

#include "transupp.h"

#include "./jpegcomp.h"

#include "./cdjpeg.h"

#include "jconfigint.h"

extern void jpeg_mem_dest_tj(j_compress_ptr, unsigned char **, unsigned long *,

                             boolean);

extern void jpeg_mem_src_tj(j_decompress_ptr, const unsigned char *,

                            unsigned long);

#define PAD(v, p)  ((v + (p) - 1) & (~((p) - 1)))

#define IS_POW2(x)  (((x) & (x - 1)) == 0)

/* Error handling (based on example in example.txt) */

static THREAD_LOCAL char errStr[JMSG_LENGTH_MAX] = "No error";

struct my_error_mgr {

  struct jpeg_error_mgr pub;

  jmp_buf setjmp_buffer;

  void (*emit_message) (j_common_ptr, int);

  boolean warning, stopOnWarning;

};

typedef struct my_error_mgr *my_error_ptr;

#define JMESSAGE(code, string)  string,

static const char *turbojpeg_message_table[] = {

#include "cderror.h"

  NULL

};

static void my_error_exit(j_common_ptr cinfo)

{

  my_error_ptr myerr = (my_error_ptr)cinfo->err;

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

  longjmp(myerr->setjmp_buffer, 1);

}

/* Based on output_message() in jerror.c */

static void my_output_message(j_common_ptr cinfo)

{

  (*cinfo->err->format_message) (cinfo, errStr);

}

static void my_emit_message(j_common_ptr cinfo, int msg_level)

{

  my_error_ptr myerr = (my_error_ptr)cinfo->err;

  myerr->emit_message(cinfo, msg_level);

  if (msg_level < 0) {

    myerr->warning = TRUE;

    if (myerr->stopOnWarning) longjmp(myerr->setjmp_buffer, 1);

  }

}

/* Global structures, macros, etc. */

enum { COMPRESS = 1, DECOMPRESS = 2 };

typedef struct _tjinstance {

  struct jpeg_compress_struct cinfo;

  struct jpeg_decompress_struct dinfo;

  struct my_error_mgr jerr;

  int init, headerRead;

  char errStr[JMSG_LENGTH_MAX];

  boolean isInstanceError;

} tjinstance;

static const int pixelsize[TJ_NUMSAMP] = { 3, 3, 3, 1, 3, 3 };

static const JXFORM_CODE xformtypes[TJ_NUMXOP] = {

  JXFORM_NONE, JXFORM_FLIP_H, JXFORM_FLIP_V, JXFORM_TRANSPOSE,

  JXFORM_TRANSVERSE, JXFORM_ROT_90, JXFORM_ROT_180, JXFORM_ROT_270

};

#define NUMSF  16

static const tjscalingfactor sf[NUMSF] = {

  { 2, 1 },

  { 15, 8 },

  { 7, 4 },

  { 13, 8 },

  { 3, 2 },

  { 11, 8 },

  { 5, 4 },

  { 9, 8 },

  { 1, 1 },

  { 7, 8 },

  { 3, 4 },

  { 5, 8 },

  { 1, 2 },

  { 3, 8 },

  { 1, 4 },

  { 1, 8 }

};

static J_COLOR_SPACE pf2cs[TJ_NUMPF] = {

  JCS_EXT_RGB, JCS_EXT_BGR, JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,

  JCS_EXT_XRGB, JCS_GRAYSCALE, JCS_EXT_RGBA, JCS_EXT_BGRA, JCS_EXT_ABGR,

  JCS_EXT_ARGB, JCS_CMYK

};

static int cs2pf[JPEG_NUMCS] = {

  TJPF_UNKNOWN, TJPF_GRAY,

#if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3

  TJPF_RGB,

#elif RGB_RED == 2 && RGB_GREEN == 1 && RGB_BLUE == 0 && RGB_PIXELSIZE == 3

  TJPF_BGR,

#elif RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 4

  TJPF_RGBX,

#elif RGB_RED == 2 && RGB_GREEN == 1 && RGB_BLUE == 0 && RGB_PIXELSIZE == 4

  TJPF_BGRX,

#elif RGB_RED == 3 && RGB_GREEN == 2 && RGB_BLUE == 1 && RGB_PIXELSIZE == 4

  TJPF_XBGR,

#elif RGB_RED == 1 && RGB_GREEN == 2 && RGB_BLUE == 3 && RGB_PIXELSIZE == 4

  TJPF_XRGB,

#endif

  TJPF_UNKNOWN, TJPF_CMYK, TJPF_UNKNOWN, TJPF_RGB, TJPF_RGBX, TJPF_BGR,

  TJPF_BGRX, TJPF_XBGR, TJPF_XRGB, TJPF_RGBA, TJPF_BGRA, TJPF_ABGR, TJPF_ARGB,

  TJPF_UNKNOWN

};

#define THROWG(m) { \

  snprintf(errStr, JMSG_LENGTH_MAX, "%s", m); \

  retval = -1;  goto bailout; \

}

#define THROW_UNIX(m) { \

  snprintf(errStr, JMSG_LENGTH_MAX, "%s\n%s", m, strerror(errno)); \

  retval = -1;  goto bailout; \

}

#define THROW(m) { \

  snprintf(this->errStr, JMSG_LENGTH_MAX, "%s", m); \

  this->isInstanceError = TRUE;  THROWG(m) \

}

#define GET_INSTANCE(handle) \

  tjinstance *this = (tjinstance *)handle; \

  j_compress_ptr cinfo = NULL; \

  j_decompress_ptr dinfo = NULL; \

  \

  if (!this) { \

    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \

    return -1; \

  } \

  cinfo = &this->cinfo;  dinfo = &this->dinfo; \

  this->jerr.warning = FALSE; \

  this->isInstanceError = FALSE;

#define GET_CINSTANCE(handle) \

  tjinstance *this = (tjinstance *)handle; \

  j_compress_ptr cinfo = NULL; \

  \

  if (!this) { \

    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \

    return -1; \

  } \

  cinfo = &this->cinfo; \

  this->jerr.warning = FALSE; \

  this->isInstanceError = FALSE;

#define GET_DINSTANCE(handle) \

  tjinstance *this = (tjinstance *)handle; \

  j_decompress_ptr dinfo = NULL; \

  \

  if (!this) { \

    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \

    return -1; \

  } \

  dinfo = &this->dinfo; \

  this->jerr.warning = FALSE; \

  this->isInstanceError = FALSE;

static int getPixelFormat(int pixelSize, int flags)

{

  if (pixelSize == 1) return TJPF_GRAY;

  if (pixelSize == 3) {

    if (flags & TJ_BGR) return TJPF_BGR;

    else return TJPF_RGB;

  }

  if (pixelSize == 4) {

    if (flags & TJ_ALPHAFIRST) {

      if (flags & TJ_BGR) return TJPF_XBGR;

      else return TJPF_XRGB;

    } else {

      if (flags & TJ_BGR) return TJPF_BGRX;

      else return TJPF_RGBX;

    }

  }

  return -1;

}

static void setCompDefaults(struct jpeg_compress_struct *cinfo,

                            int pixelFormat, int subsamp, int jpegQual,

                            int flags)

{

#ifndef NO_GETENV

  char *env = NULL;

#endif

  cinfo->in_color_space = pf2cs[pixelFormat];

  cinfo->input_components = tjPixelSize[pixelFormat];

  jpeg_set_defaults(cinfo);

#ifndef NO_GETENV

  if ((env = getenv("TJ_OPTIMIZE")) != NULL && strlen(env) > 0 &&

      !strcmp(env, "1"))

    cinfo->optimize_coding = TRUE;

  if ((env = getenv("TJ_ARITHMETIC")) != NULL && strlen(env) > 0 &&

      !strcmp(env, "1"))

    cinfo->arith_code = TRUE;

  if ((env = getenv("TJ_RESTART")) != NULL && strlen(env) > 0) {

    int temp = -1;

    char tempc = 0;

    if (sscanf(env, "%d%c", &temp, &tempc) >= 1 && temp >= 0 &&

        temp <= 65535) {

      if (toupper(tempc) == 'B') {

        cinfo->restart_interval = temp;

        cinfo->restart_in_rows = 0;

      } else

        cinfo->restart_in_rows = temp;

    }

  }

#endif

  if (jpegQual >= 0) {

    jpeg_set_quality(cinfo, jpegQual, TRUE);

    if (jpegQual >= 96 || flags & TJFLAG_ACCURATEDCT)

      cinfo->dct_method = JDCT_ISLOW;

    else

      cinfo->dct_method = JDCT_FASTEST;

  }

  if (subsamp == TJSAMP_GRAY)

    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);

  else if (pixelFormat == TJPF_CMYK)

    jpeg_set_colorspace(cinfo, JCS_YCCK);

  else

    jpeg_set_colorspace(cinfo, JCS_YCbCr);

  if (flags & TJFLAG_PROGRESSIVE)

    jpeg_simple_progression(cinfo);

#ifndef NO_GETENV

  else if ((env = getenv("TJ_PROGRESSIVE")) != NULL && strlen(env) > 0 &&

           !strcmp(env, "1"))

    jpeg_simple_progression(cinfo);

#endif

  cinfo->comp_info[0].h_samp_factor = tjMCUWidth[subsamp] / 8;

  cinfo->comp_info[1].h_samp_factor = 1;

  cinfo->comp_info[2].h_samp_factor = 1;

  if (cinfo->num_components > 3)

    cinfo->comp_info[3].h_samp_factor = tjMCUWidth[subsamp] / 8;

  cinfo->comp_info[0].v_samp_factor = tjMCUHeight[subsamp] / 8;

  cinfo->comp_info[1].v_samp_factor = 1;

  cinfo->comp_info[2].v_samp_factor = 1;

  if (cinfo->num_components > 3)

    cinfo->comp_info[3].v_samp_factor = tjMCUHeight[subsamp] / 8;

}

static int getSubsamp(j_decompress_ptr dinfo)

{

  int retval = -1, i, k;

  /* The sampling factors actually have no meaning with grayscale JPEG files,

     and in fact it's possible to generate grayscale JPEGs with sampling

     factors > 1 (even though those sampling factors are ignored by the

     decompressor.)  Thus, we need to treat grayscale as a special case. */

  if (dinfo->num_components == 1 && dinfo->jpeg_color_space == JCS_GRAYSCALE)

    return TJSAMP_GRAY;

  for (i = 0; i < NUMSUBOPT; i++) {

    if (dinfo->num_components == pixelsize[i] ||

        ((dinfo->jpeg_color_space == JCS_YCCK ||

          dinfo->jpeg_color_space == JCS_CMYK) &&

         pixelsize[i] == 3 && dinfo->num_components == 4)) {

      if (dinfo->comp_info[0].h_samp_factor == tjMCUWidth[i] / 8 &&

          dinfo->comp_info[0].v_samp_factor == tjMCUHeight[i] / 8) {

        int match = 0;

        for (k = 1; k < dinfo->num_components; k++) {

          int href = 1, vref = 1;

          if ((dinfo->jpeg_color_space == JCS_YCCK ||

               dinfo->jpeg_color_space == JCS_CMYK) && k == 3) {

            href = tjMCUWidth[i] / 8;  vref = tjMCUHeight[i] / 8;

          }

          if (dinfo->comp_info[k].h_samp_factor == href &&

              dinfo->comp_info[k].v_samp_factor == vref)

            match++;

        }

        if (match == dinfo->num_components - 1) {

          retval = i;  break;

        }

      }

      /* Handle 4:2:2 and 4:4:0 images whose sampling factors are specified

         in non-standard ways. */

      if (dinfo->comp_info[0].h_samp_factor == 2 &&

          dinfo->comp_info[0].v_samp_factor == 2 &&

          (i == TJSAMP_422 || i == TJSAMP_440)) {

        int match = 0;

        for (k = 1; k < dinfo->num_components; k++) {

          int href = tjMCUHeight[i] / 8, vref = tjMCUWidth[i] / 8;

          if ((dinfo->jpeg_color_space == JCS_YCCK ||

               dinfo->jpeg_color_space == JCS_CMYK) && k == 3) {

            href = vref = 2;

          }

          if (dinfo->comp_info[k].h_samp_factor == href &&

              dinfo->comp_info[k].v_samp_factor == vref)

            match++;

        }

        if (match == dinfo->num_components - 1) {

          retval = i;  break;

        }

      }

      /* Handle 4:4:4 images whose sampling factors are specified in

         non-standard ways. */

      if (dinfo->comp_info[0].h_samp_factor *

          dinfo->comp_info[0].v_samp_factor <=

          D_MAX_BLOCKS_IN_MCU / pixelsize[i] && i == TJSAMP_444) {

        int match = 0;

        for (k = 1; k < dinfo->num_components; k++) {

          if (dinfo->comp_info[k].h_samp_factor ==

              dinfo->comp_info[0].h_samp_factor &&

              dinfo->comp_info[k].v_samp_factor ==

              dinfo->comp_info[0].v_samp_factor)

            match++;

          if (match == dinfo->num_components - 1) {

            retval = i;  break;

          }

        }

      }

    }

  }

  return retval;

}

/* General API functions */

DLLEXPORT char *tjGetErrorStr2(tjhandle handle)

{

  tjinstance *this = (tjinstance *)handle;

  if (this && this->isInstanceError) {

    this->isInstanceError = FALSE;

    return this->errStr;

  } else

    return errStr;

}

DLLEXPORT char *tjGetErrorStr(void)

{

  return errStr;

}

DLLEXPORT int tjGetErrorCode(tjhandle handle)

{

  tjinstance *this = (tjinstance *)handle;

  if (this && this->jerr.warning) return TJERR_WARNING;

  else return TJERR_FATAL;

}

DLLEXPORT int tjDestroy(tjhandle handle)

{

  GET_INSTANCE(handle);

  if (setjmp(this->jerr.setjmp_buffer)) return -1;

  if (this->init & COMPRESS) jpeg_destroy_compress(cinfo);

  if (this->init & DECOMPRESS) jpeg_destroy_decompress(dinfo);

  free(this);

  return 0;

}

/* These are exposed mainly because Windows can't malloc() and free() across

   DLL boundaries except when the CRT DLL is used, and we don't use the CRT DLL

   with turbojpeg.dll for compatibility reasons.  However, these functions

   can potentially be used for other purposes by different implementations. */

DLLEXPORT void tjFree(unsigned char *buf)

{

  free(buf);

}

DLLEXPORT unsigned char *tjAlloc(int bytes)

{

  return (unsigned char *)malloc(bytes);

}

/* Compressor  */

static tjhandle _tjInitCompress(tjinstance *this)

{

  static unsigned char buffer[1];

  unsigned char *buf = buffer;

  unsigned long size = 1;

  /* This is also straight out of example.txt */

  this->cinfo.err = jpeg_std_error(&this->jerr.pub);

  this->jerr.pub.error_exit = my_error_exit;

  this->jerr.pub.output_message = my_output_message;

  this->jerr.emit_message = this->jerr.pub.emit_message;

  this->jerr.pub.emit_message = my_emit_message;

  this->jerr.pub.addon_message_table = turbojpeg_message_table;

  this->jerr.pub.first_addon_message = JMSG_FIRSTADDONCODE;

  this->jerr.pub.last_addon_message = JMSG_LASTADDONCODE;

  if (setjmp(this->jerr.setjmp_buffer)) {

    /* If we get here, the JPEG code has signaled an error. */

    free(this);

    return NULL;

  }

  jpeg_create_compress(&this->cinfo);

  /* Make an initial call so it will create the destination manager */

  jpeg_mem_dest_tj(&this->cinfo, &buf, &size, 0);

  this->init |= COMPRESS;

  return (tjhandle)this;

}

DLLEXPORT tjhandle tjInitCompress(void)

{

  tjinstance *this = NULL;

  if ((this = (tjinstance *)malloc(sizeof(tjinstance))) == NULL) {

    snprintf(errStr, JMSG_LENGTH_MAX,

             "tjInitCompress(): Memory allocation failure");

    return NULL;

  }

  MEMZERO(this, sizeof(tjinstance));

  snprintf(this->errStr, JMSG_LENGTH_MAX, "No error");

  return _tjInitCompress(this);

}

DLLEXPORT unsigned long tjBufSize(int width, int height, int jpegSubsamp)

{

  unsigned long long retval = 0;

  int mcuw, mcuh, chromasf;

  if (width < 1 || height < 1 || jpegSubsamp < 0 || jpegSubsamp >= NUMSUBOPT)

    THROWG("tjBufSize(): Invalid argument");

  /* This allows for rare corner cases in which a JPEG image can actually be

     larger than the uncompressed input (we wouldn't mention it if it hadn't

     happened before.) */

  mcuw = tjMCUWidth[jpegSubsamp];

  mcuh = tjMCUHeight[jpegSubsamp];

  chromasf = jpegSubsamp == TJSAMP_GRAY ? 0 : 4 * 64 / (mcuw * mcuh);

  retval = PAD(width, mcuw) * PAD(height, mcuh) * (2ULL + chromasf) + 2048ULL;

  if (retval > (unsigned long long)((unsigned long)-1))

    THROWG("tjBufSize(): Image is too large");

bailout:

  return (unsigned long)retval;

}

DLLEXPORT unsigned long TJBUFSIZE(int width, int height)

{

  unsigned long long retval = 0;

  if (width < 1 || height < 1)

    THROWG("TJBUFSIZE(): Invalid argument");

  /* This allows for rare corner cases in which a JPEG image can actually be

     larger than the uncompressed input (we wouldn't mention it if it hadn't

     happened before.) */

  retval = PAD(width, 16) * PAD(height, 16) * 6ULL + 2048ULL;

  if (retval > (unsigned long long)((unsigned long)-1))

    THROWG("TJBUFSIZE(): Image is too large");

bailout:

  return (unsigned long)retval;

}

DLLEXPORT unsigned long tjBufSizeYUV2(int width, int pad, int height,

                                      int subsamp)

{

  unsigned long long retval = 0;

  int nc, i;

  if (subsamp < 0 || subsamp >= NUMSUBOPT)

    THROWG("tjBufSizeYUV2(): Invalid argument");

  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);

  for (i = 0; i < nc; i++) {

    int pw = tjPlaneWidth(i, width, subsamp);

    int stride = PAD(pw, pad);

    int ph = tjPlaneHeight(i, height, subsamp);

    if (pw < 0 || ph < 0) return -1;

    else retval += (unsigned long long)stride * ph;

  }

  if (retval > (unsigned long long)((unsigned long)-1))

    THROWG("tjBufSizeYUV2(): Image is too large");

bailout:

  return (unsigned long)retval;

}

DLLEXPORT unsigned long tjBufSizeYUV(int width, int height, int subsamp)

{

  return tjBufSizeYUV2(width, 4, height, subsamp);

}

DLLEXPORT unsigned long TJBUFSIZEYUV(int width, int height, int subsamp)

{

  return tjBufSizeYUV(width, height, subsamp);

}

DLLEXPORT int tjPlaneWidth(int componentID, int width, int subsamp)

{

  int pw, nc, retval = 0;

  if (width < 1 || subsamp < 0 || subsamp >= TJ_NUMSAMP)

    THROWG("tjPlaneWidth(): Invalid argument");

  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);

  if (componentID < 0 || componentID >= nc)

    THROWG("tjPlaneWidth(): Invalid argument");

  pw = PAD(width, tjMCUWidth[subsamp] / 8);

  if (componentID == 0)

    retval = pw;

  else

    retval = pw * 8 / tjMCUWidth[subsamp];

bailout:

  return retval;

}

DLLEXPORT int tjPlaneHeight(int componentID, int height, int subsamp)

{

  int ph, nc, retval = 0;

  if (height < 1 || subsamp < 0 || subsamp >= TJ_NUMSAMP)

    THROWG("tjPlaneHeight(): Invalid argument");

  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);

  if (componentID < 0 || componentID >= nc)

    THROWG("tjPlaneHeight(): Invalid argument");

  ph = PAD(height, tjMCUHeight[subsamp] / 8);

  if (componentID == 0)

    retval = ph;

  else

    retval = ph * 8 / tjMCUHeight[subsamp];

bailout:

  return retval;

}

DLLEXPORT unsigned long tjPlaneSizeYUV(int componentID, int width, int stride,

                                       int height, int subsamp)

{

  unsigned long long retval = 0;

  int pw, ph;

  if (width < 1 || height < 1 || subsamp < 0 || subsamp >= NUMSUBOPT)

    THROWG("tjPlaneSizeYUV(): Invalid argument");

  pw = tjPlaneWidth(componentID, width, subsamp);

  ph = tjPlaneHeight(componentID, height, subsamp);

  if (pw < 0 || ph < 0) return -1;

  if (stride == 0) stride = pw;

  else stride = abs(stride);

  retval = (unsigned long long)stride * (ph - 1) + pw;

  if (retval > (unsigned long long)((unsigned long)-1))

    THROWG("tjPlaneSizeYUV(): Image is too large");

bailout:

  return (unsigned long)retval;

}

DLLEXPORT int tjCompress2(tjhandle handle, const unsigned char *srcBuf,

                          int width, int pitch, int height, int pixelFormat,

                          unsigned char **jpegBuf, unsigned long *jpegSize,

                          int jpegSubsamp, int jpegQual, int flags)

{

  int i, retval = 0, alloc = 1;

  JSAMPROW *row_pointer = NULL;

  GET_CINSTANCE(handle)

  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;

  if ((this->init & COMPRESS) == 0)

    THROW("tjCompress2(): Instance has not been initialized for compression");

  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||

      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||

      jpegSize == NULL || jpegSubsamp < 0 || jpegSubsamp >= NUMSUBOPT ||

      jpegQual < 0 || jpegQual > 100)

    THROW("tjCompress2(): Invalid argument");

  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];

  if ((row_pointer = (JSAMPROW *)malloc(sizeof(JSAMPROW) * height)) == NULL)

    THROW("tjCompress2(): Memory allocation failure");

  if (setjmp(this->jerr.setjmp_buffer)) {

    /* If we get here, the JPEG code has signaled an error. */

    retval = -1;  goto bailout;

  }

  cinfo->image_width = width;

  cinfo->image_height = height;

#ifndef NO_PUTENV

  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");

  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");

  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");

#endif

  if (flags & TJFLAG_NOREALLOC) {

    alloc = 0;  *jpegSize = tjBufSize(width, height, jpegSubsamp);

  }

  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);

  setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual, flags);

  jpeg_start_compress(cinfo, TRUE);

  for (i = 0; i < height; i++) {

    if (flags & TJFLAG_BOTTOMUP)

      row_pointer[i] = (JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];

    else

      row_pointer[i] = (JSAMPROW)&srcBuf[i * (size_t)pitch];

  }

  while (cinfo->next_scanline < cinfo->image_height)

    jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],

                         cinfo->image_height - cinfo->next_scanline);

  jpeg_finish_compress(cinfo);

bailout:

  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);

  free(row_pointer);

  if (this->jerr.warning) retval = -1;

  this->jerr.stopOnWarning = FALSE;

  return retval;

}

DLLEXPORT int tjCompress(tjhandle handle, unsigned char *srcBuf, int width,

                         int pitch, int height, int pixelSize,

                         unsigned char *jpegBuf, unsigned long *jpegSize,

                         int jpegSubsamp, int jpegQual, int flags)

{

  int retval = 0;

  unsigned long size;

  if (flags & TJ_YUV) {

    size = tjBufSizeYUV(width, height, jpegSubsamp);

    retval = tjEncodeYUV2(handle, srcBuf, width, pitch, height,

                          getPixelFormat(pixelSize, flags), jpegBuf,

                          jpegSubsamp, flags);

  } else {

    retval = tjCompress2(handle, srcBuf, width, pitch, height,

                         getPixelFormat(pixelSize, flags), &jpegBuf, &size,

                         jpegSubsamp, jpegQual, flags | TJFLAG_NOREALLOC);

  }

  *jpegSize = size;

  return retval;

}

DLLEXPORT int tjEncodeYUVPlanes(tjhandle handle, const unsigned char *srcBuf,

                                int width, int pitch, int height,

                                int pixelFormat, unsigned char **dstPlanes,

                                int *strides, int subsamp, int flags)

{

  JSAMPROW *row_pointer = NULL;

  JSAMPLE *_tmpbuf[MAX_COMPONENTS], *_tmpbuf2[MAX_COMPONENTS];

  JSAMPROW *tmpbuf[MAX_COMPONENTS], *tmpbuf2[MAX_COMPONENTS];

  JSAMPROW *outbuf[MAX_COMPONENTS];

  int i, retval = 0, row, pw0, ph0, pw[MAX_COMPONENTS], ph[MAX_COMPONENTS];

  JSAMPLE *ptr;

  jpeg_component_info *compptr;

  GET_CINSTANCE(handle);

  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;

  for (i = 0; i < MAX_COMPONENTS; i++) {

    tmpbuf[i] = NULL;  _tmpbuf[i] = NULL;

    tmpbuf2[i] = NULL;  _tmpbuf2[i] = NULL;  outbuf[i] = NULL;

  }

  if ((this->init & COMPRESS) == 0)

    THROW("tjEncodeYUVPlanes(): Instance has not been initialized for compression");

  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||

      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || !dstPlanes ||

      !dstPlanes[0] || subsamp < 0 || subsamp >= NUMSUBOPT)

    THROW("tjEncodeYUVPlanes(): Invalid argument");

  if (subsamp != TJSAMP_GRAY && (!dstPlanes[1] || !dstPlanes[2]))

    THROW("tjEncodeYUVPlanes(): Invalid argument");

  if (pixelFormat == TJPF_CMYK)

    THROW("tjEncodeYUVPlanes(): Cannot generate YUV images from CMYK pixels");

  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];

  if (setjmp(this->jerr.setjmp_buffer)) {

    /* If we get here, the JPEG code has signaled an error. */

    retval = -1;  goto bailout;

  }

  cinfo->image_width = width;

  cinfo->image_height = height;

#ifndef NO_PUTENV

  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");

  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");

  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");

#endif

  setCompDefaults(cinfo, pixelFormat, subsamp, -1, flags);

  /* Execute only the parts of jpeg_start_compress() that we need.  If we

     were to call the whole jpeg_start_compress() function, then it would try

     to write the file headers, which could overflow the output buffer if the

     YUV image were very small. */

  if (cinfo->global_state != CSTATE_START)

    THROW("tjEncodeYUVPlanes(): libjpeg API is in the wrong state");

  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);

  jinit_c_master_control(cinfo, FALSE);

  jinit_color_converter(cinfo);

  jinit_downsampler(cinfo);

  (*cinfo->cconvert->start_pass) (cinfo);

  pw0 = PAD(width, cinfo->max_h_samp_factor);

  ph0 = PAD(height, cinfo->max_v_samp_factor);

  if ((row_pointer = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph0)) == NULL)

    THROW("tjEncodeYUVPlanes(): Memory allocation failure");

  for (i = 0; i < height; i++) {

    if (flags & TJFLAG_BOTTOMUP)

      row_pointer[i] = (JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];

    else

      row_pointer[i] = (JSAMPROW)&srcBuf[i * (size_t)pitch];

  }

  if (height < ph0)

    for (i = height; i < ph0; i++) row_pointer[i] = row_pointer[height - 1];

  for (i = 0; i < cinfo->num_components; i++) {

    compptr = &cinfo->comp_info[i];

    _tmpbuf[i] = (JSAMPLE *)malloc(

      PAD((compptr->width_in_blocks * cinfo->max_h_samp_factor * DCTSIZE) /

          compptr->h_samp_factor, 32) *

      cinfo->max_v_samp_factor + 32);

    if (!_tmpbuf[i])

      THROW("tjEncodeYUVPlanes(): Memory allocation failure");

    tmpbuf[i] =

      (JSAMPROW *)malloc(sizeof(JSAMPROW) * cinfo->max_v_samp_factor);

    if (!tmpbuf[i])

      THROW("tjEncodeYUVPlanes(): Memory allocation failure");

    for (row = 0; row < cinfo->max_v_samp_factor; row++) {

      unsigned char *_tmpbuf_aligned =

        (unsigned char *)PAD((size_t)_tmpbuf[i], 32);

      tmpbuf[i][row] = &_tmpbuf_aligned[

        PAD((compptr->width_in_blocks * cinfo->max_h_samp_factor * DCTSIZE) /

            compptr->h_samp_factor, 32) * row];

    }

    _tmpbuf2[i] =

      (JSAMPLE *)malloc(PAD(compptr->width_in_blocks * DCTSIZE, 32) *

                        compptr->v_samp_factor + 32);

    if (!_tmpbuf2[i])

      THROW("tjEncodeYUVPlanes(): Memory allocation failure");

    tmpbuf2[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * compptr->v_samp_factor);

    if (!tmpbuf2[i])

      THROW("tjEncodeYUVPlanes(): Memory allocation failure");

    for (row = 0; row < compptr->v_samp_factor; row++) {

      unsigned char *_tmpbuf2_aligned =

        (unsigned char *)PAD((size_t)_tmpbuf2[i], 32);

      tmpbuf2[i][row] =

        &_tmpbuf2_aligned[PAD(compptr->width_in_blocks * DCTSIZE, 32) * row];

    }

    pw[i] = pw0 * compptr->h_samp_factor / cinfo->max_h_samp_factor;

    ph[i] = ph0 * compptr->v_samp_factor / cinfo->max_v_samp_factor;

    outbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph[i]);

    if (!outbuf[i])

      THROW("tjEncodeYUVPlanes(): Memory allocation failure");

    ptr = dstPlanes[i];

    for (row = 0; row < ph[i]; row++) {

      outbuf[i][row] = ptr;

      ptr += (strides && strides[i] != 0) ? strides[i] : pw[i];

    }

  }

  if (setjmp(this->jerr.setjmp_buffer)) {

    /* If we get here, the JPEG code has signaled an error. */

    retval = -1;  goto bailout;

  }

  for (row = 0; row < ph0; row += cinfo->max_v_samp_factor) {

    (*cinfo->cconvert->color_convert) (cinfo, &row_pointer[row], tmpbuf, 0,

                                       cinfo->max_v_samp_factor);

    (cinfo->downsample->downsample) (cinfo, tmpbuf, 0, tmpbuf2, 0);

    for (i = 0, compptr = cinfo->comp_info; i < cinfo->num_components;

         i++, compptr++)

      jcopy_sample_rows(tmpbuf2[i], 0, outbuf[i],

        row * compptr->v_samp_factor / cinfo->max_v_samp_factor,

        compptr->v_samp_factor, pw[i]);

  }

  cinfo->next_scanline += height;

  jpeg_abort_compress(cinfo);

bailout:

  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);

  free(row_pointer);

  for (i = 0; i < MAX_COMPONENTS; i++) {

    free(tmpbuf[i]);

    free(_tmpbuf[i]);

    free(tmpbuf2[i]);

    free(_tmpbuf2[i]);

    free(outbuf[i]);

  }

  if (this->jerr.warning) retval = -1;

  this->jerr.stopOnWarning = FALSE;

  return retval;

}