/*

 * Copyright (C)2009-2015, 2017, 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.

 */

#ifndef __TURBOJPEG_H__

#define __TURBOJPEG_H__

#if defined(_WIN32) && defined(DLLDEFINE)

#define DLLEXPORT  __declspec(dllexport)

#else

#define DLLEXPORT

#endif

#define DLLCALL

/**

 * @addtogroup TurboJPEG

 * TurboJPEG API.  This API provides an interface for generating, decoding, and

 * transforming planar YUV and JPEG images in memory.

 *

 * @anchor YUVnotes

 * YUV Image Format Notes

 * ----------------------

 * Technically, the JPEG format uses the YCbCr colorspace (which is technically

 * not a colorspace but a color transform), but per the convention of the

 * digital video community, the TurboJPEG API uses "YUV" to refer to an image

 * format consisting of Y, Cb, and Cr image planes.

 *

 * Each plane is simply a 2D array of bytes, each byte representing the value

 * of one of the components (Y, Cb, or Cr) at a particular location in the

 * image.  The width and height of each plane are determined by the image

 * width, height, and level of chrominance subsampling.   The luminance plane

 * width is the image width padded to the nearest multiple of the horizontal

 * subsampling factor (2 in the case of 4:2:0 and 4:2:2, 4 in the case of

 * 4:1:1, 1 in the case of 4:4:4 or grayscale.)  Similarly, the luminance plane

 * height is the image height padded to the nearest multiple of the vertical

 * subsampling factor (2 in the case of 4:2:0 or 4:4:0, 1 in the case of 4:4:4

 * or grayscale.)  This is irrespective of any additional padding that may be

 * specified as an argument to the various YUV functions.  The chrominance

 * plane width is equal to the luminance plane width divided by the horizontal

 * subsampling factor, and the chrominance plane height is equal to the

 * luminance plane height divided by the vertical subsampling factor.

 *

 * For example, if the source image is 35 x 35 pixels and 4:2:2 subsampling is

 * used, then the luminance plane would be 36 x 35 bytes, and each of the

 * chrominance planes would be 18 x 35 bytes.  If you specify a line padding of

 * 4 bytes on top of this, then the luminance plane would be 36 x 35 bytes, and

 * each of the chrominance planes would be 20 x 35 bytes.

 *

 * @{

 */

/**

 * The number of chrominance subsampling options

 */

#define TJ_NUMSAMP  6

/**

 * Chrominance subsampling options.

 * When pixels are converted from RGB to YCbCr (see #TJCS_YCbCr) or from CMYK

 * to YCCK (see #TJCS_YCCK) as part of the JPEG compression process, some of

 * the Cb and Cr (chrominance) components can be discarded or averaged together

 * to produce a smaller image with little perceptible loss of image clarity

 * (the human eye is more sensitive to small changes in brightness than to

 * small changes in color.)  This is called "chrominance subsampling".

 */

enum TJSAMP {

  /**

   * 4:4:4 chrominance subsampling (no chrominance subsampling).  The JPEG or

   * YUV image will contain one chrominance component for every pixel in the

   * source image.

   */

  TJSAMP_444 = 0,

  /**

   * 4:2:2 chrominance subsampling.  The JPEG or YUV image will contain one

   * chrominance component for every 2x1 block of pixels in the source image.

   */

  TJSAMP_422,

  /**

   * 4:2:0 chrominance subsampling.  The JPEG or YUV image will contain one

   * chrominance component for every 2x2 block of pixels in the source image.

   */

  TJSAMP_420,

  /**

   * Grayscale.  The JPEG or YUV image will contain no chrominance components.

   */

  TJSAMP_GRAY,

  /**

   * 4:4:0 chrominance subsampling.  The JPEG or YUV image will contain one

   * chrominance component for every 1x2 block of pixels in the source image.

   *

   * @note 4:4:0 subsampling is not fully accelerated in libjpeg-turbo.

   */

  TJSAMP_440,

  /**

   * 4:1:1 chrominance subsampling.  The JPEG or YUV image will contain one

   * chrominance component for every 4x1 block of pixels in the source image.

   * JPEG images compressed with 4:1:1 subsampling will be almost exactly the

   * same size as those compressed with 4:2:0 subsampling, and in the

   * aggregate, both subsampling methods produce approximately the same

   * perceptual quality.  However, 4:1:1 is better able to reproduce sharp

   * horizontal features.

   *

   * @note 4:1:1 subsampling is not fully accelerated in libjpeg-turbo.

   */

  TJSAMP_411

};

/**

 * MCU block width (in pixels) for a given level of chrominance subsampling.

 * MCU block sizes:

 * - 8x8 for no subsampling or grayscale

 * - 16x8 for 4:2:2

 * - 8x16 for 4:4:0

 * - 16x16 for 4:2:0

 * - 32x8 for 4:1:1

 */

static const int tjMCUWidth[TJ_NUMSAMP]  = { 8, 16, 16, 8, 8, 32 };

/**

 * MCU block height (in pixels) for a given level of chrominance subsampling.

 * MCU block sizes:

 * - 8x8 for no subsampling or grayscale

 * - 16x8 for 4:2:2

 * - 8x16 for 4:4:0

 * - 16x16 for 4:2:0

 * - 32x8 for 4:1:1

 */

static const int tjMCUHeight[TJ_NUMSAMP] = { 8, 8, 16, 8, 16, 8 };

/**

 * The number of pixel formats

 */

#define TJ_NUMPF  12

/**

 * Pixel formats

 */

enum TJPF {

  /**

   * RGB pixel format.  The red, green, and blue components in the image are

   * stored in 3-byte pixels in the order R, G, B from lowest to highest byte

   * address within each pixel.

   */

  TJPF_RGB = 0,

  /**

   * BGR pixel format.  The red, green, and blue components in the image are

   * stored in 3-byte pixels in the order B, G, R from lowest to highest byte

   * address within each pixel.

   */

  TJPF_BGR,

  /**

   * RGBX pixel format.  The red, green, and blue components in the image are

   * stored in 4-byte pixels in the order R, G, B from lowest to highest byte

   * address within each pixel.  The X component is ignored when compressing

   * and undefined when decompressing.

   */

  TJPF_RGBX,

  /**

   * BGRX pixel format.  The red, green, and blue components in the image are

   * stored in 4-byte pixels in the order B, G, R from lowest to highest byte

   * address within each pixel.  The X component is ignored when compressing

   * and undefined when decompressing.

   */

  TJPF_BGRX,

  /**

   * XBGR pixel format.  The red, green, and blue components in the image are

   * stored in 4-byte pixels in the order R, G, B from highest to lowest byte

   * address within each pixel.  The X component is ignored when compressing

   * and undefined when decompressing.

   */

  TJPF_XBGR,

  /**

   * XRGB pixel format.  The red, green, and blue components in the image are

   * stored in 4-byte pixels in the order B, G, R from highest to lowest byte

   * address within each pixel.  The X component is ignored when compressing

   * and undefined when decompressing.

   */

  TJPF_XRGB,

  /**

   * Grayscale pixel format.  Each 1-byte pixel represents a luminance

   * (brightness) level from 0 to 255.

   */

  TJPF_GRAY,

  /**

   * RGBA pixel format.  This is the same as @ref TJPF_RGBX, except that when

   * decompressing, the X component is guaranteed to be 0xFF, which can be

   * interpreted as an opaque alpha channel.

   */

  TJPF_RGBA,

  /**

   * BGRA pixel format.  This is the same as @ref TJPF_BGRX, except that when

   * decompressing, the X component is guaranteed to be 0xFF, which can be

   * interpreted as an opaque alpha channel.

   */

  TJPF_BGRA,

  /**

   * ABGR pixel format.  This is the same as @ref TJPF_XBGR, except that when

   * decompressing, the X component is guaranteed to be 0xFF, which can be

   * interpreted as an opaque alpha channel.

   */

  TJPF_ABGR,

  /**

   * ARGB pixel format.  This is the same as @ref TJPF_XRGB, except that when

   * decompressing, the X component is guaranteed to be 0xFF, which can be

   * interpreted as an opaque alpha channel.

   */

  TJPF_ARGB,

  /**

   * CMYK pixel format.  Unlike RGB, which is an additive color model used

   * primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive

   * color model used primarily for printing.  In the CMYK color model, the

   * value of each color component typically corresponds to an amount of cyan,

   * magenta, yellow, or black ink that is applied to a white background.  In

   * order to convert between CMYK and RGB, it is necessary to use a color

   * management system (CMS.)  A CMS will attempt to map colors within the

   * printer's gamut to perceptually similar colors in the display's gamut and

   * vice versa, but the mapping is typically not 1:1 or reversible, nor can it

   * be defined with a simple formula.  Thus, such a conversion is out of scope

   * for a codec library.  However, the TurboJPEG API allows for compressing

   * CMYK pixels into a YCCK JPEG image (see #TJCS_YCCK) and decompressing YCCK

   * JPEG images into CMYK pixels.

   */

  TJPF_CMYK,

  /**

   * Unknown pixel format.  Currently this is only used by #tjLoadImage().

   */

  TJPF_UNKNOWN = -1

};

/**

 * Red offset (in bytes) for a given pixel format.  This specifies the number

 * of bytes that the red component is offset from the start of the pixel.  For

 * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,

 * then the red component will be <tt>pixel[tjRedOffset[TJ_BGRX]]</tt>.  This

 * will be -1 if the pixel format does not have a red component.

 */

static const int tjRedOffset[TJ_NUMPF] = {

  0, 2, 0, 2, 3, 1, -1, 0, 2, 3, 1, -1

};

/**

 * Green offset (in bytes) for a given pixel format.  This specifies the number

 * of bytes that the green component is offset from the start of the pixel.

 * For instance, if a pixel of format TJ_BGRX is stored in

 * <tt>char pixel[]</tt>, then the green component will be

 * <tt>pixel[tjGreenOffset[TJ_BGRX]]</tt>.  This will be -1 if the pixel format

 * does not have a green component.

 */

static const int tjGreenOffset[TJ_NUMPF] = {

  1, 1, 1, 1, 2, 2, -1, 1, 1, 2, 2, -1

};

/**

 * Blue offset (in bytes) for a given pixel format.  This specifies the number

 * of bytes that the Blue component is offset from the start of the pixel.  For

 * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,

 * then the blue component will be <tt>pixel[tjBlueOffset[TJ_BGRX]]</tt>.  This

 * will be -1 if the pixel format does not have a blue component.

 */

static const int tjBlueOffset[TJ_NUMPF] = {

  2, 0, 2, 0, 1, 3, -1, 2, 0, 1, 3, -1

};

/**

 * Alpha offset (in bytes) for a given pixel format.  This specifies the number

 * of bytes that the Alpha component is offset from the start of the pixel.

 * For instance, if a pixel of format TJ_BGRA is stored in

 * <tt>char pixel[]</tt>, then the alpha component will be

 * <tt>pixel[tjAlphaOffset[TJ_BGRA]]</tt>.  This will be -1 if the pixel format

 * does not have an alpha component.

 */

static const int tjAlphaOffset[TJ_NUMPF] = {

  -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1

};

/**

 * Pixel size (in bytes) for a given pixel format

 */

static const int tjPixelSize[TJ_NUMPF] = {

  3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4

};

/**

 * The number of JPEG colorspaces

 */

#define TJ_NUMCS  5

/**

 * JPEG colorspaces

 */

enum TJCS {

  /**

   * RGB colorspace.  When compressing the JPEG image, the R, G, and B

   * components in the source image are reordered into image planes, but no

   * colorspace conversion or subsampling is performed.  RGB JPEG images can be

   * decompressed to any of the extended RGB pixel formats or grayscale, but

   * they cannot be decompressed to YUV images.

   */

  TJCS_RGB = 0,

  /**

   * YCbCr colorspace.  YCbCr is not an absolute colorspace but rather a

   * mathematical transformation of RGB designed solely for storage and

   * transmission.  YCbCr images must be converted to RGB before they can

   * actually be displayed.  In the YCbCr colorspace, the Y (luminance)

   * component represents the black & white portion of the original image, and

   * the Cb and Cr (chrominance) components represent the color portion of the

   * original image.  Originally, the analog equivalent of this transformation

   * allowed the same signal to drive both black & white and color televisions,

   * but JPEG images use YCbCr primarily because it allows the color data to be

   * optionally subsampled for the purposes of reducing bandwidth or disk

   * space.  YCbCr is the most common JPEG colorspace, and YCbCr JPEG images

   * can be compressed from and decompressed to any of the extended RGB pixel

   * formats or grayscale, or they can be decompressed to YUV planar images.

   */

  TJCS_YCbCr,

  /**

   * Grayscale colorspace.  The JPEG image retains only the luminance data (Y

   * component), and any color data from the source image is discarded.

   * Grayscale JPEG images can be compressed from and decompressed to any of

   * the extended RGB pixel formats or grayscale, or they can be decompressed

   * to YUV planar images.

   */

  TJCS_GRAY,

  /**

   * CMYK colorspace.  When compressing the JPEG image, the C, M, Y, and K

   * components in the source image are reordered into image planes, but no

   * colorspace conversion or subsampling is performed.  CMYK JPEG images can

   * only be decompressed to CMYK pixels.

   */

  TJCS_CMYK,

  /**

   * YCCK colorspace.  YCCK (AKA "YCbCrK") is not an absolute colorspace but

   * rather a mathematical transformation of CMYK designed solely for storage

   * and transmission.  It is to CMYK as YCbCr is to RGB.  CMYK pixels can be

   * reversibly transformed into YCCK, and as with YCbCr, the chrominance

   * components in the YCCK pixels can be subsampled without incurring major

   * perceptual loss.  YCCK JPEG images can only be compressed from and

   * decompressed to CMYK pixels.

   */

  TJCS_YCCK

};

/**

 * The uncompressed source/destination image is stored in bottom-up (Windows,

 * OpenGL) order, not top-down (X11) order.

 */

#define TJFLAG_BOTTOMUP  2

/**

 * When decompressing an image that was compressed using chrominance

 * subsampling, use the fastest chrominance upsampling algorithm available in

 * the underlying codec.  The default is to use smooth upsampling, which

 * creates a smooth transition between neighboring chrominance components in

 * order to reduce upsampling artifacts in the decompressed image.

 */

#define TJFLAG_FASTUPSAMPLE  256

/**

 * Disable buffer (re)allocation.  If passed to one of the JPEG compression or

 * transform functions, this flag will cause those functions to generate an

 * error if the JPEG image buffer is invalid or too small rather than

 * attempting to allocate or reallocate that buffer.  This reproduces the

 * behavior of earlier versions of TurboJPEG.

 */

#define TJFLAG_NOREALLOC  1024

/**

 * Use the fastest DCT/IDCT algorithm available in the underlying codec.  The

 * default if this flag is not specified is implementation-specific.  For

 * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast

 * algorithm by default when compressing, because this has been shown to have

 * only a very slight effect on accuracy, but it uses the accurate algorithm

 * when decompressing, because this has been shown to have a larger effect.

 */

#define TJFLAG_FASTDCT  2048

/**

 * Use the most accurate DCT/IDCT algorithm available in the underlying codec.

 * The default if this flag is not specified is implementation-specific.  For

 * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast

 * algorithm by default when compressing, because this has been shown to have

 * only a very slight effect on accuracy, but it uses the accurate algorithm

 * when decompressing, because this has been shown to have a larger effect.

 */

#define TJFLAG_ACCURATEDCT  4096

/**

 * Immediately discontinue the current compression/decompression/transform

 * operation if the underlying codec throws a warning (non-fatal error).  The

 * default behavior is to allow the operation to complete unless a fatal error

 * is encountered.

 */

#define TJFLAG_STOPONWARNING  8192

/**

 * Use progressive entropy coding in JPEG images generated by the compression

 * and transform functions.  Progressive entropy coding will generally improve

 * compression relative to baseline entropy coding (the default), but it will

 * reduce compression and decompression performance considerably.

 */

#define TJFLAG_PROGRESSIVE  16384

/**

 * The number of error codes

 */

#define TJ_NUMERR  2

/**

 * Error codes

 */

enum TJERR {

  /**

   * The error was non-fatal and recoverable, but the image may still be

   * corrupt.

   */

  TJERR_WARNING = 0,

  /**

   * The error was fatal and non-recoverable.

   */

  TJERR_FATAL

};

/**

 * The number of transform operations

 */

#define TJ_NUMXOP  8

/**

 * Transform operations for #tjTransform()

 */

enum TJXOP {

  /**

   * Do not transform the position of the image pixels

   */

  TJXOP_NONE = 0,

  /**

   * Flip (mirror) image horizontally.  This transform is imperfect if there

   * are any partial MCU blocks on the right edge (see #TJXOPT_PERFECT.)

   */

  TJXOP_HFLIP,

  /**

   * Flip (mirror) image vertically.  This transform is imperfect if there are

   * any partial MCU blocks on the bottom edge (see #TJXOPT_PERFECT.)

   */

  TJXOP_VFLIP,

  /**

   * Transpose image (flip/mirror along upper left to lower right axis.)  This

   * transform is always perfect.

   */

  TJXOP_TRANSPOSE,

  /**

   * Transverse transpose image (flip/mirror along upper right to lower left

   * axis.)  This transform is imperfect if there are any partial MCU blocks in

   * the image (see #TJXOPT_PERFECT.)

   */

  TJXOP_TRANSVERSE,

  /**

   * Rotate image clockwise by 90 degrees.  This transform is imperfect if

   * there are any partial MCU blocks on the bottom edge (see

   * #TJXOPT_PERFECT.)

   */

  TJXOP_ROT90,

  /**

   * Rotate image 180 degrees.  This transform is imperfect if there are any

   * partial MCU blocks in the image (see #TJXOPT_PERFECT.)

   */

  TJXOP_ROT180,

  /**

   * Rotate image counter-clockwise by 90 degrees.  This transform is imperfect

   * if there are any partial MCU blocks on the right edge (see

   * #TJXOPT_PERFECT.)

   */

  TJXOP_ROT270

};

/**

 * This option will cause #tjTransform() to return an error if the transform is

 * not perfect.  Lossless transforms operate on MCU blocks, whose size depends

 * on the level of chrominance subsampling used (see #tjMCUWidth

 * and #tjMCUHeight.)  If the image's width or height is not evenly divisible

 * by the MCU block size, then there will be partial MCU blocks on the right

 * and/or bottom edges.  It is not possible to move these partial MCU blocks to

 * the top or left of the image, so any transform that would require that is

 * "imperfect."  If this option is not specified, then any partial MCU blocks

 * that cannot be transformed will be left in place, which will create

 * odd-looking strips on the right or bottom edge of the image.

 */

#define TJXOPT_PERFECT  1

/**

 * This option will cause #tjTransform() to discard any partial MCU blocks that

 * cannot be transformed.

 */

#define TJXOPT_TRIM  2

/**

 * This option will enable lossless cropping.  See #tjTransform() for more

 * information.

 */

#define TJXOPT_CROP  4

/**

 * This option will discard the color data in the input image and produce

 * a grayscale output image.

 */

#define TJXOPT_GRAY  8

/**

 * This option will prevent #tjTransform() from outputting a JPEG image for

 * this particular transform (this can be used in conjunction with a custom

 * filter to capture the transformed DCT coefficients without transcoding

 * them.)

 */

#define TJXOPT_NOOUTPUT  16

/**

 * This option will enable progressive entropy coding in the output image

 * generated by this particular transform.  Progressive entropy coding will

 * generally improve compression relative to baseline entropy coding (the

 * default), but it will reduce compression and decompression performance

 * considerably.

 */

#define TJXOPT_PROGRESSIVE  32

/**

 * This option will prevent #tjTransform() from copying any extra markers

 * (including EXIF and ICC profile data) from the source image to the output

 * image.

 */

#define TJXOPT_COPYNONE  64

/**

 * Scaling factor

 */

typedef struct {

  /**

   * Numerator

   */

  int num;

  /**

   * Denominator

   */

  int denom;

} tjscalingfactor;

/**

 * Cropping region

 */

typedef struct {

  /**

   * The left boundary of the cropping region.  This must be evenly divisible

   * by the MCU block width (see #tjMCUWidth.)

   */

  int x;

  /**

   * The upper boundary of the cropping region.  This must be evenly divisible

   * by the MCU block height (see #tjMCUHeight.)

   */

  int y;

  /**

   * The width of the cropping region. Setting this to 0 is the equivalent of

   * setting it to the width of the source JPEG image - x.

   */

  int w;

  /**

   * The height of the cropping region. Setting this to 0 is the equivalent of

   * setting it to the height of the source JPEG image - y.

   */

  int h;

} tjregion;

/**

 * Lossless transform

 */

typedef struct tjtransform {

  /**

   * Cropping region

   */

  tjregion r;

  /**

   * One of the @ref TJXOP "transform operations"

   */

  int op;

  /**

   * The bitwise OR of one of more of the @ref TJXOPT_CROP "transform options"

   */

  int options;

  /**

   * Arbitrary data that can be accessed within the body of the callback

   * function

   */

  void *data;

  /**

   * A callback function that can be used to modify the DCT coefficients

   * after they are losslessly transformed but before they are transcoded to a

   * new JPEG image.  This allows for custom filters or other transformations

   * to be applied in the frequency domain.

   *

   * @param coeffs pointer to an array of transformed DCT coefficients.  (NOTE:

   * this pointer is not guaranteed to be valid once the callback returns, so

   * applications wishing to hand off the DCT coefficients to another function

   * or library should make a copy of them within the body of the callback.)

   *

   * @param arrayRegion #tjregion structure containing the width and height of

   * the array pointed to by <tt>coeffs</tt> as well as its offset relative to

   * the component plane.  TurboJPEG implementations may choose to split each

   * component plane into multiple DCT coefficient arrays and call the callback

   * function once for each array.

   *

   * @param planeRegion #tjregion structure containing the width and height of

   * the component plane to which <tt>coeffs</tt> belongs

   *

   * @param componentID ID number of the component plane to which

   * <tt>coeffs</tt> belongs (Y, Cb, and Cr have, respectively, ID's of 0, 1,

   * and 2 in typical JPEG images.)

   *

   * @param transformID ID number of the transformed image to which

   * <tt>coeffs</tt> belongs.  This is the same as the index of the transform

   * in the <tt>transforms</tt> array that was passed to #tjTransform().

   *

   * @param transform a pointer to a #tjtransform structure that specifies the

   * parameters and/or cropping region for this transform

   *

   * @return 0 if the callback was successful, or -1 if an error occurred.

   */

  int (*customFilter) (short *coeffs, tjregion arrayRegion,

                       tjregion planeRegion, int componentIndex,

                       int transformIndex, struct tjtransform *transform);

} tjtransform;

/**

 * TurboJPEG instance handle

 */

typedef void *tjhandle;

/**

 * Pad the given width to the nearest 32-bit boundary

 */

#define TJPAD(width)  (((width) + 3) & (~3))

/**

 * Compute the scaled value of <tt>dimension</tt> using the given scaling

 * factor.  This macro performs the integer equivalent of <tt>ceil(dimension *</tt>

 * scalingFactor).

 */

#define TJSCALED(dimension, scalingFactor) \

  ((dimension * scalingFactor.num + scalingFactor.denom - 1) / \

   scalingFactor.denom)

#ifdef __cplusplus

extern "C" {

#endif

/**

 * Create a TurboJPEG compressor instance.

 *

 * @return a handle to the newly-created instance, or NULL if an error

 * occurred (see #tjGetErrorStr2().)

 */

DLLEXPORT tjhandle tjInitCompress(void);

/**

 * Compress an RGB, grayscale, or CMYK image into a JPEG image.

 *

 * @param handle a handle to a TurboJPEG compressor or transformer instance

 *

 * @param srcBuf pointer to an image buffer containing RGB, grayscale, or

 * CMYK pixels to be compressed

 *

 * @param width width (in pixels) of the source image

 *

 * @param pitch bytes per line in the source image.  Normally, this should be

 * <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded, or

 * <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of the image

 * is padded to the nearest 32-bit boundary, as is the case for Windows

 * bitmaps.  You can also be clever and use this parameter to skip lines, etc.

 * Setting this parameter to 0 is the equivalent of setting it to

 * <tt>width * #tjPixelSize[pixelFormat]</tt>.

 *

 * @param height height (in pixels) of the source image

 *

 * @param pixelFormat pixel format of the source image (see @ref TJPF

 * "Pixel formats".)

 *

 * @param jpegBuf address of a pointer to an image buffer that will receive the

 * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer

 * to accommodate the size of the JPEG image.  Thus, you can choose to:

 * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and

 * let TurboJPEG grow the buffer as needed,

 * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer

 * for you, or

 * -# pre-allocate the buffer to a "worst case" size determined by calling

 * #tjBufSize().  This should ensure that the buffer never has to be

 * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)

 * .

 * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your

 * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,

 * you should always check <tt>*jpegBuf</tt> upon return from this function, as

 * it may have changed.

 *

 * @param jpegSize pointer to an unsigned long variable that holds the size of

 * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated

 * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.

 * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in

 * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being

 * reused from a previous call to one of the JPEG compression functions, then

 * <tt>*jpegSize</tt> is ignored.

 *

 * @param jpegSubsamp the level of chrominance subsampling to be used when

 * generating the JPEG image (see @ref TJSAMP

 * "Chrominance subsampling options".)

 *

 * @param jpegQual the image quality of the generated JPEG image (1 = worst,

 * 100 = best)

 *

 * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT

 * "flags"

 *

 * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()

 * and #tjGetErrorCode().)

*/

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);

/**

 * Compress a YUV planar image into a JPEG image.

 *

 * @param handle a handle to a TurboJPEG compressor or transformer instance

 *

 * @param srcBuf pointer to an image buffer containing a YUV planar image to be

 * compressed.  The size of this buffer should match the value returned by

 * #tjBufSizeYUV2() for the given image width, height, padding, and level of

 * chrominance subsampling.  The Y, U (Cb), and V (Cr) image planes should be

 * stored sequentially in the source buffer (refer to @ref YUVnotes

 * "YUV Image Format Notes".)

 *

 * @param width width (in pixels) of the source image.  If the width is not an

 * even multiple of the MCU block width (see #tjMCUWidth), then an intermediate

 * buffer copy will be performed within TurboJPEG.

 *

 * @param pad the line padding used in the source image.  For instance, if each

 * line in each plane of the YUV image is padded to the nearest multiple of 4

 * bytes, then <tt>pad</tt> should be set to 4.

 *

 * @param height height (in pixels) of the source image.  If the height is not

 * an even multiple of the MCU block height (see #tjMCUHeight), then an

 * intermediate buffer copy will be performed within TurboJPEG.

 *

 * @param subsamp the level of chrominance subsampling used in the source

 * image (see @ref TJSAMP "Chrominance subsampling options".)

 *

 * @param jpegBuf address of a pointer to an image buffer that will receive the

 * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer to

 * accommodate the size of the JPEG image.  Thus, you can choose to:

 * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and

 * let TurboJPEG grow the buffer as needed,

 * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer

 * for you, or

 * -# pre-allocate the buffer to a "worst case" size determined by calling

 * #tjBufSize().  This should ensure that the buffer never has to be

 * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)

 * .

 * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your

 * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,

 * you should always check <tt>*jpegBuf</tt> upon return from this function, as

 * it may have changed.

 *

 * @param jpegSize pointer to an unsigned long variable that holds the size of

 * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated

 * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.

 * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in

 * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being

 * reused from a previous call to one of the JPEG compression functions, then

 * <tt>*jpegSize</tt> is ignored.

 *

 * @param jpegQual the image quality of the generated JPEG image (1 = worst,

 * 100 = best)

 *

 * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT

 * "flags"

 *

 * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()

 * and #tjGetErrorCode().)

*/

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

                                int width, int pad, int height, int subsamp,

                                unsigned char **jpegBuf,

                                unsigned long *jpegSize, int jpegQual,

                                int flags);

/**

 * Compress a set of Y, U (Cb), and V (Cr) image planes into a JPEG image.

 *

 * @param handle a handle to a TurboJPEG compressor or transformer instance

 *

 * @param srcPlanes an array of pointers to Y, U (Cb), and V (Cr) image planes

 * (or just a Y plane, if compressing a grayscale image) that contain a YUV

 * image to be compressed.  These planes can be contiguous or non-contiguous in

 * memory.  The size of each plane should match the value returned by

 * #tjPlaneSizeYUV() for the given image width, height, strides, and level of

 * chrominance subsampling.  Refer to @ref YUVnotes "YUV Image Format Notes"

 * for more details.

 *

 * @param width width (in pixels) of the source image.  If the width is not an

 * even multiple of the MCU block width (see #tjMCUWidth), then an intermediate

 * buffer copy will be performed within TurboJPEG.

 *

 * @param strides an array of integers, each specifying the number of bytes per

 * line in the corresponding plane of the YUV source image.  Setting the stride

 * for any plane to 0 is the same as setting it to the plane width (see

 * @ref YUVnotes "YUV Image Format Notes".)  If <tt>strides</tt> is NULL, then

 * the strides for all planes will be set to their respective plane widths.

 * You can adjust the strides in order to specify an arbitrary amount of line

 * padding in each plane or to create a JPEG image from a subregion of a larger

 * YUV planar image.

 *

 * @param height height (in pixels) of the source image.  If the height is not

 * an even multiple of the MCU block height (see #tjMCUHeight), then an

 * intermediate buffer copy will be performed within TurboJPEG.

 *

 * @param subsamp the level of chrominance subsampling used in the source

 * image (see @ref TJSAMP "Chrominance subsampling options".)

 *

 * @param jpegBuf address of a pointer to an image buffer that will receive the

 * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer to

 * accommodate the size of the JPEG image.  Thus, you can choose to:

 * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and

 * let TurboJPEG grow the buffer as needed,

 * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer

 * for you, or

 * -# pre-allocate the buffer to a "worst case" size determined by calling

 * #tjBufSize().  This should ensure that the buffer never has to be

 * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)

 * .

 * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your

 * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,

 * you should always check <tt>*jpegBuf</tt> upon return from this function, as

 * it may have changed.

 *

 * @param jpegSize pointer to an unsigned long variable that holds the size of

 * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated

 * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.

 * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in

 * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being

 * reused from a previous call to one of the JPEG compression functions, then

 * <tt>*jpegSize</tt> is ignored.

 *

 * @param jpegQual the image quality of the generated JPEG image (1 = worst,

 * 100 = best)

 *

 * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT

 * "flags"

 *