/* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0

   specification is now totally obsolete and deprecated for new applications and

   images. This file was was created solely in order to read unconverted images

   still present on some users' computer systems. It will never be extended

   to write such files. Writing new-style JPEG compressed TIFFs is implemented

   in tif_jpeg.c.

   The code is carefully crafted to robustly read all gathered JPEG-in-TIFF

   testfiles, and anticipate as much as possible all other... But still, it may

   fail on some. If you encounter problems, please report them on the TIFF

   mailing list and/or to Joris Van Damme <info@awaresystems.be>.

   Please read the file called "TIFF Technical Note #2" if you need to be

   convinced this compression scheme is bad and breaks TIFF. That document

   is linked to from the LibTiff site <http://www.remotesensing.org/libtiff/>

   and from AWare Systems' TIFF section

   <http://www.awaresystems.be/imaging/tiff.html>. It is also absorbed

   in Adobe's specification supplements, marked "draft" up to this day, but

   supported by the TIFF community.

   This file interfaces with Release 6B of the JPEG Library written by the

   Independent JPEG Group. Previous versions of this file required a hack inside

   the LibJpeg library. This version no longer requires that. Remember to

   remove the hack if you update from the old version.

   Copyright (c) Joris Van Damme <info@awaresystems.be>

   Copyright (c) AWare Systems <http://www.awaresystems.be/>

   The licence agreement for this file is the same as the rest of the LibTiff

   library.

   IN NO EVENT SHALL JORIS VAN DAMME OR AWARE SYSTEMS BE LIABLE FOR

   ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

   OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

   WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

   LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

   OF THIS SOFTWARE.

   Joris Van Damme and/or AWare Systems may be available for custom

   development. If you like what you see, and need anything similar or related,

   contact <info@awaresystems.be>.

*/

/* What is what, and what is not?

   This decoder starts with an input stream, that is essentially the

   JpegInterchangeFormat stream, if any, followed by the strile data, if any.

   This stream is read in OJPEGReadByte and related functions.

   It analyzes the start of this stream, until it encounters non-marker data,

   i.e. compressed image data. Some of the header markers it sees have no actual

   content, like the SOI marker, and APP/COM markers that really shouldn't even

   be there. Some other markers do have content, and the valuable bits and

   pieces of information in these markers are saved, checking all to verify that

   the stream is more or less within expected bounds. This happens inside the

   OJPEGReadHeaderInfoSecStreamXxx functions.

   Some OJPEG imagery contains no valid JPEG header markers. This situation is

   picked up on if we've seen no SOF marker when we're at the start of the

   compressed image data. In this case, the tables are read from JpegXxxTables

   tags, and the other bits and pieces of information is initialized to its most

   basic value. This is implemented in the OJPEGReadHeaderInfoSecTablesXxx

   functions.

   When this is complete, a good and valid JPEG header can be assembled, and

   this is passed through to LibJpeg. When that's done, the remainder of the

   input stream, i.e. the compressed image data, can be passed through

   unchanged. This is done in OJPEGWriteStream functions.

   LibTiff rightly expects to know the subsampling values before decompression.

   Just like in new-style JPEG-in-TIFF, though, or even more so, actually, the

   YCbCrsubsampling tag is notoriously unreliable. To correct these tag values

   with the ones inside the JPEG stream, the first part of the input stream is

   pre-scanned in OJPEGSubsamplingCorrect, making no note of any other data,

   reporting no warnings or errors, up to the point where either these values

   are read, or it's clear they aren't there. This means that some of the data

   is read twice, but we feel speed in correcting these values is important

   enough to warrant this sacrifice. Although there is currently no define or

   other configuration mechanism to disable this behavior, the actual header

   scanning is build to robustly respond with error report if it should

   encounter an uncorrected mismatch of subsampling values. See

   OJPEGReadHeaderInfoSecStreamSof.

   The restart interval and restart markers are the most tricky part... The

   restart interval can be specified in a tag. It can also be set inside the

   input JPEG stream. It can be used inside the input JPEG stream. If reading

   from strile data, we've consistently discovered the need to insert restart

   markers in between the different striles, as is also probably the most likely

   interpretation of the original TIFF 6.0 specification. With all this setting

   of interval, and actual use of markers that is not predictable at the time of

   valid JPEG header assembly, the restart thing may turn out the Achilles heel

   of this implementation. Fortunately, most OJPEG writer vendors succeed in

   reading back what they write, which may be the reason why we've been able to

   discover ways that seem to work.

   Some special provision is made for planarconfig separate OJPEG files. These

   seem to consistently contain header info, a SOS marker, a plane, SOS marker,

   plane, SOS, and plane. This may or may not be a valid JPEG configuration, we

   don't know and don't care. We want LibTiff to be able to access the planes

   individually, without huge buffering inside LibJpeg, anyway. So we compose

   headers to feed to LibJpeg, in this case, that allow us to pass a single

   plane such that LibJpeg sees a valid single-channel JPEG stream. Locating

   subsequent SOS markers, and thus subsequent planes, is done inside

   OJPEGReadSecondarySos.

   The benefit of the scheme is... that it works, basically. We know of no other

   that does. It works without checking software tag, or otherwise going about

   things in an OJPEG flavor specific manner. Instead, it is a single scheme,

   that covers the cases with and without JpegInterchangeFormat, with and

   without striles, with part of the header in JpegInterchangeFormat and

   remainder in first strile, etc. It is forgiving and robust, may likely work

   with OJPEG flavors we've not seen yet, and makes most out of the data.

   Another nice side-effect is that a complete JPEG single valid stream is build

   if planarconfig is not separate (vast majority). We may one day use that to

   build converters to JPEG, and/or to new-style JPEG compression inside TIFF.

   A disadvantage is the lack of random access to the individual striles. This

   is the reason for much of the complicated restart-and-position stuff inside

   OJPEGPreDecode. Applications would do well accessing all striles in order, as

   this will result in a single sequential scan of the input stream, and no

   restarting of LibJpeg decoding session.

*/

#include "tiffiop.h"

#ifdef OJPEG_SUPPORT

/* Configuration defines here are:

 * JPEG_ENCAP_EXTERNAL: The normal way to call libjpeg, uses longjump. In some

 * environments, like eg LibTiffDelphi, this is not possible. For this reason,

 * the actual calls to libjpeg, with longjump stuff, are encapsulated in

 * dedicated functions. When JPEG_ENCAP_EXTERNAL is defined, these encapsulating

 * functions are declared external to this unit, and can be defined elsewhere to

 * use stuff other then longjump. The default mode, without JPEG_ENCAP_EXTERNAL,

 * implements the call encapsulators here, internally, with normal longjump.

 * SETJMP, LONGJMP, JMP_BUF: On some machines/environments a longjump equivalent

 * is conveniently available, but still it may be worthwhile to use _setjmp or

 * sigsetjmp in place of plain setjmp. These macros will make it easier. It is

 * useless to fiddle with these if you define JPEG_ENCAP_EXTERNAL. OJPEG_BUFFER:

 * Define the size of the desired buffer here. Should be small enough so as to

 * guarantee instant processing, optimal streaming and optimal use of processor

 * cache, but also big enough so as to not result in significant call overhead.

 * It should be at least a few bytes to accommodate some structures (this is

 * verified in asserts), but it would not be sensible to make it this small

 * anyway, and it should be at most 64K since it is indexed with uint16_t. We

 * recommend 2K. EGYPTIANWALK: You could also define EGYPTIANWALK here, but it

 * is not used anywhere and has absolutely no effect. That is why most people

 * insist the EGYPTIANWALK is a bit silly.

 */

/* define LIBJPEG_ENCAP_EXTERNAL */

#define SETJMP(jbuf) setjmp(jbuf)

#define LONGJMP(jbuf, code) longjmp(jbuf, code)

#define JMP_BUF jmp_buf

#define OJPEG_BUFFER 2048

/* define EGYPTIANWALK */

#define JPEG_MARKER_SOF0 0xC0

#define JPEG_MARKER_SOF1 0xC1

#define JPEG_MARKER_SOF3 0xC3

#define JPEG_MARKER_DHT 0xC4

#define JPEG_MARKER_RST0 0XD0

#define JPEG_MARKER_SOI 0xD8

#define JPEG_MARKER_EOI 0xD9

#define JPEG_MARKER_SOS 0xDA

#define JPEG_MARKER_DQT 0xDB

#define JPEG_MARKER_DRI 0xDD

#define JPEG_MARKER_APP0 0xE0

#define JPEG_MARKER_COM 0xFE

#define FIELD_OJPEG_JPEGINTERCHANGEFORMAT (FIELD_CODEC + 0)

#define FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH (FIELD_CODEC + 1)

#define FIELD_OJPEG_JPEGQTABLES (FIELD_CODEC + 2)

#define FIELD_OJPEG_JPEGDCTABLES (FIELD_CODEC + 3)

#define FIELD_OJPEG_JPEGACTABLES (FIELD_CODEC + 4)

#define FIELD_OJPEG_JPEGPROC (FIELD_CODEC + 5)

#define FIELD_OJPEG_JPEGRESTARTINTERVAL (FIELD_CODEC + 6)

static const TIFFField ojpegFields[] = {

    {TIFFTAG_JPEGIFOFFSET, 1, 1, TIFF_LONG8, 0, TIFF_SETGET_UINT64,

     FIELD_OJPEG_JPEGINTERCHANGEFORMAT, TRUE, FALSE, "JpegInterchangeFormat",

     NULL},

    {TIFFTAG_JPEGIFBYTECOUNT, 1, 1, TIFF_LONG8, 0, TIFF_SETGET_UINT64,

     FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH, TRUE, FALSE,

     "JpegInterchangeFormatLength", NULL},

    {TIFFTAG_JPEGQTABLES, TIFF_VARIABLE2, TIFF_VARIABLE2, TIFF_LONG8, 0,

     TIFF_SETGET_C32_UINT64, FIELD_OJPEG_JPEGQTABLES, FALSE, TRUE,

     "JpegQTables", NULL},

    {TIFFTAG_JPEGDCTABLES, TIFF_VARIABLE2, TIFF_VARIABLE2, TIFF_LONG8, 0,

     TIFF_SETGET_C32_UINT64, FIELD_OJPEG_JPEGDCTABLES, FALSE, TRUE,

     "JpegDcTables", NULL},

    {TIFFTAG_JPEGACTABLES, TIFF_VARIABLE2, TIFF_VARIABLE2, TIFF_LONG8, 0,

     TIFF_SETGET_C32_UINT64, FIELD_OJPEG_JPEGACTABLES, FALSE, TRUE,

     "JpegAcTables", NULL},

    {TIFFTAG_JPEGPROC, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16,

     FIELD_OJPEG_JPEGPROC, FALSE, FALSE, "JpegProc", NULL},

    {TIFFTAG_JPEGRESTARTINTERVAL, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16,

     FIELD_OJPEG_JPEGRESTARTINTERVAL, FALSE, FALSE, "JpegRestartInterval",

     NULL},

};

#ifndef LIBJPEG_ENCAP_EXTERNAL

#include <setjmp.h>

#endif

#include "jerror.h"

#include "jpeglib.h"

typedef struct jpeg_source_mgr tiff_ojpeg_source_mgr;

typedef struct jpeg_error_mgr tiff_ojpeg_error_mgr;

typedef struct jpeg_common_struct tiff_ojpeg_common_struct;

typedef struct jpeg_decompress_struct tiff_ojpeg_decompress_struct;

typedef enum

{

    osibsNotSetYet,

    osibsJpegInterchangeFormat,

    osibsStrile,

    osibsEof

} OJPEGStateInBufferSource;

typedef enum

{

    ososSoi,

    ososQTable0,

    ososQTable1,

    ososQTable2,

    ososQTable3,

    ososDcTable0,

    ososDcTable1,

    ososDcTable2,

    ososDcTable3,

    ososAcTable0,

    ososAcTable1,

    ososAcTable2,

    ososAcTable3,

    ososDri,

    ososSof,

    ososSos,

    ososCompressed,

    ososRst,

    ososEoi

} OJPEGStateOutState;

typedef struct

{

    TIFF *tif;

    int decoder_ok;

    int error_in_raw_data_decoding;

#ifndef LIBJPEG_ENCAP_EXTERNAL

    JMP_BUF exit_jmpbuf;

#endif

    TIFFVGetMethod vgetparent;

    TIFFVSetMethod vsetparent;

    TIFFPrintMethod printdir;

    uint64_t file_size;

    uint32_t image_width;

    uint32_t image_length;

    uint32_t strile_width;

    uint32_t strile_length;

    uint32_t strile_length_total;

    uint8_t samples_per_pixel;

    uint8_t plane_sample_offset;

    uint8_t samples_per_pixel_per_plane;

    uint64_t jpeg_interchange_format;

    uint64_t jpeg_interchange_format_length;

    uint8_t jpeg_proc;

    uint8_t subsamplingcorrect;

    uint8_t subsamplingcorrect_done;

    uint8_t subsampling_tag;

    uint8_t subsampling_hor;

    uint8_t subsampling_ver;

    uint8_t subsampling_force_desubsampling_inside_decompression;

    uint8_t qtable_offset_count;

    uint8_t dctable_offset_count;

    uint8_t actable_offset_count;

    uint64_t qtable_offset[3];

    uint64_t dctable_offset[3];

    uint64_t actable_offset[3];

    uint8_t *qtable[4];

    uint8_t *dctable[4];

    uint8_t *actable[4];

    uint16_t restart_interval;

    uint8_t restart_index;

    uint8_t sof_log;

    uint8_t sof_marker_id;

    uint32_t sof_x;

    uint32_t sof_y;

    uint8_t sof_c[3];

    uint8_t sof_hv[3];

    uint8_t sof_tq[3];

    uint8_t sos_cs[3];

    uint8_t sos_tda[3];

    struct

    {

        uint8_t log;

        OJPEGStateInBufferSource in_buffer_source;

        uint32_t in_buffer_next_strile;

        uint64_t in_buffer_file_pos;

        uint64_t in_buffer_file_togo;

    } sos_end[3];

    uint8_t readheader_done;

    uint8_t writeheader_done;

    uint16_t write_cursample;

    uint32_t write_curstrile;

    uint8_t libjpeg_session_active;

    uint8_t libjpeg_jpeg_query_style;

    tiff_ojpeg_error_mgr libjpeg_jpeg_error_mgr;

    tiff_ojpeg_decompress_struct libjpeg_jpeg_decompress_struct;

    tiff_ojpeg_source_mgr libjpeg_jpeg_source_mgr;

    uint8_t subsampling_convert_log;

    uint32_t subsampling_convert_ylinelen;

    uint32_t subsampling_convert_ylines;

    uint32_t subsampling_convert_clinelen;

    uint32_t subsampling_convert_clines;

    uint32_t subsampling_convert_ybuflen;

    uint32_t subsampling_convert_cbuflen;

    uint32_t subsampling_convert_ycbcrbuflen;

    uint8_t *subsampling_convert_ycbcrbuf;

    uint8_t *subsampling_convert_ybuf;

    uint8_t *subsampling_convert_cbbuf;

    uint8_t *subsampling_convert_crbuf;

    uint32_t subsampling_convert_ycbcrimagelen;

    uint8_t **subsampling_convert_ycbcrimage;

    uint32_t subsampling_convert_clinelenout;

    uint32_t subsampling_convert_state;

    uint32_t bytes_per_line;   /* if the codec outputs subsampled data, a 'line'

                                  in bytes_per_line */

    uint32_t lines_per_strile; /* and lines_per_strile means subsampling_ver

                                  desubsampled rows     */

    OJPEGStateInBufferSource in_buffer_source;

    uint32_t in_buffer_next_strile;

    uint32_t in_buffer_strile_count;

    uint64_t in_buffer_file_pos;

    uint8_t in_buffer_file_pos_log;

    uint64_t in_buffer_file_togo;

    uint16_t in_buffer_togo;

    uint8_t *in_buffer_cur;

    uint8_t in_buffer[OJPEG_BUFFER];

    OJPEGStateOutState out_state;

    uint8_t out_buffer[OJPEG_BUFFER];

    uint8_t *skip_buffer;

} OJPEGState;

static int OJPEGVGetField(TIFF *tif, uint32_t tag, va_list ap);

static int OJPEGVSetField(TIFF *tif, uint32_t tag, va_list ap);

static void OJPEGPrintDir(TIFF *tif, FILE *fd, long flags);

static int OJPEGFixupTags(TIFF *tif);

static int OJPEGSetupDecode(TIFF *tif);

static int OJPEGPreDecode(TIFF *tif, uint16_t s);

static int OJPEGPreDecodeSkipRaw(TIFF *tif);

static int OJPEGPreDecodeSkipScanlines(TIFF *tif);

static int OJPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);

static int OJPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc);

static int OJPEGDecodeScanlines(TIFF *tif, uint8_t *buf, tmsize_t cc);

static void OJPEGPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc);

static int OJPEGSetupEncode(TIFF *tif);

static int OJPEGPreEncode(TIFF *tif, uint16_t s);

static int OJPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);

static int OJPEGPostEncode(TIFF *tif);

static void OJPEGCleanup(TIFF *tif);

static void OJPEGSubsamplingCorrect(TIFF *tif);

static int OJPEGReadHeaderInfo(TIFF *tif);

static int OJPEGReadSecondarySos(TIFF *tif, uint16_t s);

static int OJPEGWriteHeaderInfo(TIFF *tif);

static void OJPEGLibjpegSessionAbort(TIFF *tif);

static int OJPEGReadHeaderInfoSec(TIFF *tif);

static int OJPEGReadHeaderInfoSecStreamDri(TIFF *tif);

static int OJPEGReadHeaderInfoSecStreamDqt(TIFF *tif);

static int OJPEGReadHeaderInfoSecStreamDht(TIFF *tif);

static int OJPEGReadHeaderInfoSecStreamSof(TIFF *tif, uint8_t marker_id);

static int OJPEGReadHeaderInfoSecStreamSos(TIFF *tif);

static int OJPEGReadHeaderInfoSecTablesQTable(TIFF *tif);

static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF *tif);

static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF *tif);

static int OJPEGReadBufferFill(OJPEGState *sp);

static int OJPEGReadByte(OJPEGState *sp, uint8_t *byte);

static int OJPEGReadBytePeek(OJPEGState *sp, uint8_t *byte);

static void OJPEGReadByteAdvance(OJPEGState *sp);

static int OJPEGReadWord(OJPEGState *sp, uint16_t *word);

static int OJPEGReadBlock(OJPEGState *sp, uint16_t len, void *mem);

static void OJPEGReadSkip(OJPEGState *sp, uint16_t len);

static int OJPEGWriteStream(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamSoi(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamQTable(TIFF *tif, uint8_t table_index, void **mem,

                                   uint32_t *len);

static void OJPEGWriteStreamDcTable(TIFF *tif, uint8_t table_index, void **mem,

                                    uint32_t *len);

static void OJPEGWriteStreamAcTable(TIFF *tif, uint8_t table_index, void **mem,

                                    uint32_t *len);

static void OJPEGWriteStreamDri(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamSof(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamSos(TIFF *tif, void **mem, uint32_t *len);

static int OJPEGWriteStreamCompressed(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamRst(TIFF *tif, void **mem, uint32_t *len);

static void OJPEGWriteStreamEoi(TIFF *tif, void **mem, uint32_t *len);

#ifdef LIBJPEG_ENCAP_EXTERNAL

extern int jpeg_create_decompress_encap(OJPEGState *sp,

                                        tiff_ojpeg_decompress_struct *cinfo);

extern int jpeg_read_header_encap(OJPEGState *sp,

                                  tiff_ojpeg_decompress_struct *cinfo,

                                  uint8_t require_image);

extern int jpeg_start_decompress_encap(OJPEGState *sp,

                                       tiff_ojpeg_decompress_struct *cinfo);

extern int jpeg_read_scanlines_encap(OJPEGState *sp,

                                     tiff_ojpeg_decompress_struct *cinfo,

                                     void *scanlines, uint32_t max_lines);

extern int jpeg_read_raw_data_encap(OJPEGState *sp,

                                    tiff_ojpeg_decompress_struct *cinfo,

                                    void *data, uint32_t max_lines);

extern void jpeg_encap_unwind(TIFF *tif);

#else

static int jpeg_create_decompress_encap(OJPEGState *sp,

                                        tiff_ojpeg_decompress_struct *j);

static int jpeg_read_header_encap(OJPEGState *sp,

                                  tiff_ojpeg_decompress_struct *cinfo,

                                  uint8_t require_image);

static int jpeg_start_decompress_encap(OJPEGState *sp,

                                       tiff_ojpeg_decompress_struct *cinfo);

static int jpeg_read_scanlines_encap(OJPEGState *sp,

                                     tiff_ojpeg_decompress_struct *cinfo,

                                     void *scanlines, uint32_t max_lines);

static int jpeg_read_raw_data_encap(OJPEGState *sp,

                                    tiff_ojpeg_decompress_struct *cinfo,

                                    void *data, uint32_t max_lines);

static void jpeg_encap_unwind(TIFF *tif);

#endif

static void

OJPEGLibjpegJpegErrorMgrOutputMessage(tiff_ojpeg_common_struct *cinfo);

static void OJPEGLibjpegJpegErrorMgrErrorExit(tiff_ojpeg_common_struct *cinfo);

static void

OJPEGLibjpegJpegSourceMgrInitSource(tiff_ojpeg_decompress_struct *cinfo);

static boolean

OJPEGLibjpegJpegSourceMgrFillInputBuffer(tiff_ojpeg_decompress_struct *cinfo);

static void

OJPEGLibjpegJpegSourceMgrSkipInputData(tiff_ojpeg_decompress_struct *cinfo,

                                       long num_bytes);

static boolean

OJPEGLibjpegJpegSourceMgrResyncToRestart(tiff_ojpeg_decompress_struct *cinfo,

                                         int desired);

static void

OJPEGLibjpegJpegSourceMgrTermSource(tiff_ojpeg_decompress_struct *cinfo);

int TIFFInitOJPEG(TIFF *tif, int scheme)

{

    static const char module[] = "TIFFInitOJPEG";

    OJPEGState *sp;

    (void)scheme;

    assert(scheme == COMPRESSION_OJPEG);

    /*

     * Merge codec-specific tag information.

     */

    if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields)))

    {

        TIFFErrorExtR(tif, module,

                      "Merging Old JPEG codec-specific tags failed");

        return 0;

    }

    /* state block */

    sp = (OJPEGState *)_TIFFmallocExt(tif, sizeof(OJPEGState));

    if (sp == NULL)

    {

        TIFFErrorExtR(tif, module, "No space for OJPEG state block");

        return (0);

    }

    _TIFFmemset(sp, 0, sizeof(OJPEGState));

    sp->tif = tif;

    sp->jpeg_proc = 1;

    sp->subsampling_hor = 2;

    sp->subsampling_ver = 2;

    TIFFSetField(tif, TIFFTAG_YCBCRSUBSAMPLING, 2, 2);

    /* tif codec methods */

    tif->tif_fixuptags = OJPEGFixupTags;

    tif->tif_setupdecode = OJPEGSetupDecode;

    tif->tif_predecode = OJPEGPreDecode;

    tif->tif_postdecode = OJPEGPostDecode;

    tif->tif_decoderow = OJPEGDecode;

    tif->tif_decodestrip = OJPEGDecode;

    tif->tif_decodetile = OJPEGDecode;

    tif->tif_setupencode = OJPEGSetupEncode;

    tif->tif_preencode = OJPEGPreEncode;

    tif->tif_postencode = OJPEGPostEncode;

    tif->tif_encoderow = OJPEGEncode;

    tif->tif_encodestrip = OJPEGEncode;

    tif->tif_encodetile = OJPEGEncode;

    tif->tif_cleanup = OJPEGCleanup;

    tif->tif_data = (uint8_t *)sp;

    /* tif tag methods */

    sp->vgetparent = tif->tif_tagmethods.vgetfield;

    tif->tif_tagmethods.vgetfield = OJPEGVGetField;

    sp->vsetparent = tif->tif_tagmethods.vsetfield;

    tif->tif_tagmethods.vsetfield = OJPEGVSetField;

    sp->printdir = tif->tif_tagmethods.printdir;

    tif->tif_tagmethods.printdir = OJPEGPrintDir;

    /* Some OJPEG files don't have strip or tile offsets or bytecounts tags.

       Some others do, but have totally meaningless or corrupt values

       in these tags. In these cases, the JpegInterchangeFormat stream is

       reliable. In any case, this decoder reads the compressed data itself,

       from the most reliable locations, and we need to notify encapsulating

       LibTiff not to read raw strips or tiles for us. */

    tif->tif_flags |= TIFF_NOREADRAW;

    return (1);

}

static int OJPEGVGetField(TIFF *tif, uint32_t tag, va_list ap)

{

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    switch (tag)

    {

        case TIFFTAG_JPEGIFOFFSET:

            *va_arg(ap, uint64_t *) = (uint64_t)sp->jpeg_interchange_format;

            break;

        case TIFFTAG_JPEGIFBYTECOUNT:

            *va_arg(ap, uint64_t *) =

                (uint64_t)sp->jpeg_interchange_format_length;

            break;

        case TIFFTAG_YCBCRSUBSAMPLING:

            if (sp->subsamplingcorrect_done == 0)

                OJPEGSubsamplingCorrect(tif);

            *va_arg(ap, uint16_t *) = (uint16_t)sp->subsampling_hor;

            *va_arg(ap, uint16_t *) = (uint16_t)sp->subsampling_ver;

            break;

        case TIFFTAG_JPEGQTABLES:

            *va_arg(ap, uint32_t *) = (uint32_t)sp->qtable_offset_count;

            *va_arg(ap, const void **) = (const void *)sp->qtable_offset;

            break;

        case TIFFTAG_JPEGDCTABLES:

            *va_arg(ap, uint32_t *) = (uint32_t)sp->dctable_offset_count;

            *va_arg(ap, const void **) = (const void *)sp->dctable_offset;

            break;

        case TIFFTAG_JPEGACTABLES:

            *va_arg(ap, uint32_t *) = (uint32_t)sp->actable_offset_count;

            *va_arg(ap, const void **) = (const void *)sp->actable_offset;

            break;

        case TIFFTAG_JPEGPROC:

            *va_arg(ap, uint16_t *) = (uint16_t)sp->jpeg_proc;

            break;

        case TIFFTAG_JPEGRESTARTINTERVAL:

            *va_arg(ap, uint16_t *) = sp->restart_interval;

            break;

        default:

            return (*sp->vgetparent)(tif, tag, ap);

    }

    return (1);

}

static int OJPEGVSetField(TIFF *tif, uint32_t tag, va_list ap)

{

    static const char module[] = "OJPEGVSetField";

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint32_t ma;

    uint64_t *mb;

    uint32_t n;

    const TIFFField *fip;

    switch (tag)

    {

        case TIFFTAG_JPEGIFOFFSET:

            sp->jpeg_interchange_format = (uint64_t)va_arg(ap, uint64_t);

            break;

        case TIFFTAG_JPEGIFBYTECOUNT:

            sp->jpeg_interchange_format_length = (uint64_t)va_arg(ap, uint64_t);

            break;

        case TIFFTAG_YCBCRSUBSAMPLING:

            sp->subsampling_tag = 1;

            sp->subsampling_hor = (uint8_t)va_arg(ap, uint16_vap);

            sp->subsampling_ver = (uint8_t)va_arg(ap, uint16_vap);

            tif->tif_dir.td_ycbcrsubsampling[0] = sp->subsampling_hor;

            tif->tif_dir.td_ycbcrsubsampling[1] = sp->subsampling_ver;

            break;

        case TIFFTAG_JPEGQTABLES:

            ma = (uint32_t)va_arg(ap, uint32_t);

            if (ma != 0)

            {

                if (ma > 3)

                {

                    TIFFErrorExtR(tif, module,

                                  "JpegQTables tag has incorrect count");

                    return (0);

                }

                sp->qtable_offset_count = (uint8_t)ma;

                mb = (uint64_t *)va_arg(ap, uint64_t *);

                for (n = 0; n < ma; n++)

                    sp->qtable_offset[n] = mb[n];

            }

            break;

        case TIFFTAG_JPEGDCTABLES:

            ma = (uint32_t)va_arg(ap, uint32_t);

            if (ma != 0)

            {

                if (ma > 3)

                {

                    TIFFErrorExtR(tif, module,

                                  "JpegDcTables tag has incorrect count");

                    return (0);

                }

                sp->dctable_offset_count = (uint8_t)ma;

                mb = (uint64_t *)va_arg(ap, uint64_t *);

                for (n = 0; n < ma; n++)

                    sp->dctable_offset[n] = mb[n];

            }

            break;

        case TIFFTAG_JPEGACTABLES:

            ma = (uint32_t)va_arg(ap, uint32_t);

            if (ma != 0)

            {

                if (ma > 3)

                {

                    TIFFErrorExtR(tif, module,

                                  "JpegAcTables tag has incorrect count");

                    return (0);

                }

                sp->actable_offset_count = (uint8_t)ma;

                mb = (uint64_t *)va_arg(ap, uint64_t *);

                for (n = 0; n < ma; n++)

                    sp->actable_offset[n] = mb[n];

            }

            break;

        case TIFFTAG_JPEGPROC:

            sp->jpeg_proc = (uint8_t)va_arg(ap, uint16_vap);

            break;

        case TIFFTAG_JPEGRESTARTINTERVAL:

            sp->restart_interval = (uint16_t)va_arg(ap, uint16_vap);

            break;

        default:

            return (*sp->vsetparent)(tif, tag, ap);

    }

    fip = TIFFFieldWithTag(tif, tag);

    if (fip == NULL) /* shouldn't happen */

        return (0);

    TIFFSetFieldBit(tif, fip->field_bit);

    tif->tif_flags |= TIFF_DIRTYDIRECT;

    return (1);

}

static void OJPEGPrintDir(TIFF *tif, FILE *fd, long flags)

{

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint8_t m;

    (void)flags;

    assert(sp != NULL);

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGINTERCHANGEFORMAT))

        fprintf(fd, "  JpegInterchangeFormat: %" PRIu64 "\n",

                (uint64_t)sp->jpeg_interchange_format);

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))

        fprintf(fd, "  JpegInterchangeFormatLength: %" PRIu64 "\n",

                (uint64_t)sp->jpeg_interchange_format_length);

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGQTABLES))

    {

        fprintf(fd, "  JpegQTables:");

        for (m = 0; m < sp->qtable_offset_count; m++)

            fprintf(fd, " %" PRIu64, (uint64_t)sp->qtable_offset[m]);

        fprintf(fd, "\n");

    }

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGDCTABLES))

    {

        fprintf(fd, "  JpegDcTables:");

        for (m = 0; m < sp->dctable_offset_count; m++)

            fprintf(fd, " %" PRIu64, (uint64_t)sp->dctable_offset[m]);

        fprintf(fd, "\n");

    }

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGACTABLES))

    {

        fprintf(fd, "  JpegAcTables:");

        for (m = 0; m < sp->actable_offset_count; m++)

            fprintf(fd, " %" PRIu64, (uint64_t)sp->actable_offset[m]);

        fprintf(fd, "\n");

    }

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGPROC))

        fprintf(fd, "  JpegProc: %" PRIu8 "\n", sp->jpeg_proc);

    if (TIFFFieldSet(tif, FIELD_OJPEG_JPEGRESTARTINTERVAL))

        fprintf(fd, "  JpegRestartInterval: %" PRIu16 "\n",

                sp->restart_interval);

    if (sp->printdir)

        (*sp->printdir)(tif, fd, flags);

}

static int OJPEGFixupTags(TIFF *tif)

{

    (void)tif;

    return (1);

}

static int OJPEGSetupDecode(TIFF *tif)

{

    static const char module[] = "OJPEGSetupDecode";

    TIFFWarningExtR(tif, module,

                    "Deprecated and troublesome old-style JPEG compression "

                    "mode, please convert to new-style JPEG compression and "

                    "notify vendor of writing software");

    return (1);

}

static int OJPEGPreDecode(TIFF *tif, uint16_t s)

{

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint32_t m;

    if (sp->subsamplingcorrect_done == 0)

        OJPEGSubsamplingCorrect(tif);

    if (sp->readheader_done == 0)

    {

        if (OJPEGReadHeaderInfo(tif) == 0)

            return (0);

    }

    if (sp->sos_end[s].log == 0)

    {

        if (OJPEGReadSecondarySos(tif, s) == 0)

            return (0);

    }

    if (isTiled(tif))

        m = tif->tif_dir.td_curtile;

    else

        m = tif->tif_dir.td_curstrip;

    if ((sp->writeheader_done != 0) &&

        ((sp->write_cursample != s) || (sp->write_curstrile > m)))

    {

        if (sp->libjpeg_session_active != 0)

            OJPEGLibjpegSessionAbort(tif);

        sp->writeheader_done = 0;

    }

    if (sp->writeheader_done == 0)

    {

        sp->plane_sample_offset = (uint8_t)s;

        sp->write_cursample = s;

        sp->write_curstrile = s * tif->tif_dir.td_stripsperimage;

        if ((sp->in_buffer_file_pos_log == 0) ||

            (sp->in_buffer_file_pos - sp->in_buffer_togo !=

             sp->sos_end[s].in_buffer_file_pos))

        {

            sp->in_buffer_source = sp->sos_end[s].in_buffer_source;

            sp->in_buffer_next_strile = sp->sos_end[s].in_buffer_next_strile;

            sp->in_buffer_file_pos = sp->sos_end[s].in_buffer_file_pos;

            sp->in_buffer_file_pos_log = 0;

            sp->in_buffer_file_togo = sp->sos_end[s].in_buffer_file_togo;

            sp->in_buffer_togo = 0;

            sp->in_buffer_cur = 0;

        }

        if (OJPEGWriteHeaderInfo(tif) == 0)

            return (0);

    }

    sp->subsampling_convert_state = 0;

    while (sp->write_curstrile < m)

    {

        if (sp->libjpeg_jpeg_query_style == 0)

        {

            if (OJPEGPreDecodeSkipRaw(tif) == 0)

                return (0);

        }

        else

        {

            if (OJPEGPreDecodeSkipScanlines(tif) == 0)

                return (0);

        }

        sp->write_curstrile++;

    }

    sp->decoder_ok = 1;

    return (1);

}

static int OJPEGPreDecodeSkipRaw(TIFF *tif)

{

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint32_t m;

    m = sp->lines_per_strile;

    if (sp->subsampling_convert_state != 0)

    {

        if (sp->subsampling_convert_clines - sp->subsampling_convert_state >= m)

        {

            sp->subsampling_convert_state += m;

            if (sp->subsampling_convert_state == sp->subsampling_convert_clines)

                sp->subsampling_convert_state = 0;

            return (1);

        }

        m -= sp->subsampling_convert_clines - sp->subsampling_convert_state;

        sp->subsampling_convert_state = 0;

        sp->error_in_raw_data_decoding = 0;

    }

    while (m >= sp->subsampling_convert_clines)

    {

        if (jpeg_read_raw_data_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),

                                     sp->subsampling_convert_ycbcrimage,

                                     (uint32_t)sp->subsampling_ver * 8) == 0)

            return (0);

        m -= sp->subsampling_convert_clines;

    }

    if (m > 0)

    {

        if (jpeg_read_raw_data_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),

                                     sp->subsampling_convert_ycbcrimage,

                                     (uint32_t)sp->subsampling_ver * 8) == 0)

            return (0);

        sp->subsampling_convert_state = m;

    }

    return (1);

}

static int OJPEGPreDecodeSkipScanlines(TIFF *tif)

{

    static const char module[] = "OJPEGPreDecodeSkipScanlines";

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint32_t m;

    if (sp->skip_buffer == NULL)

    {

        sp->skip_buffer = (uint8_t *)_TIFFmallocExt(tif, sp->bytes_per_line);

        if (sp->skip_buffer == NULL)

        {

            TIFFErrorExtR(tif, module, "Out of memory");

            return (0);

        }

    }

    for (m = 0; m < sp->lines_per_strile; m++)

    {

        if (jpeg_read_scanlines_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),

                                      &sp->skip_buffer, 1) == 0)

            return (0);

    }

    return (1);

}

static int OJPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)

{

    static const char module[] = "OJPEGDecode";

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    (void)s;

    if (!sp->decoder_ok)

    {

        memset(buf, 0, (size_t)cc);

        TIFFErrorExtR(tif, module,

                      "Cannot decode: decoder not correctly initialized");

        return 0;

    }

    if (sp->libjpeg_session_active == 0)

    {

        memset(buf, 0, (size_t)cc);

        /* This should normally not happen, except that it does when */

        /* using TIFFReadScanline() which calls OJPEGPostDecode() for */

        /* each scanline, which assumes that a whole strile was read */

        /* and may thus incorrectly consider it has read the whole image,

         * causing */

        /* OJPEGLibjpegSessionAbort() to be called prematurely. */

        /* Triggered by https://gitlab.com/libtiff/libtiff/-/issues/337 */

        TIFFErrorExtR(tif, module,

                      "Cannot decode: libjpeg_session_active == 0");

        return 0;

    }

    if (sp->error_in_raw_data_decoding)

    {

        memset(buf, 0, (size_t)cc);

        return 0;

    }

    if (sp->libjpeg_jpeg_query_style == 0)

    {

        if (OJPEGDecodeRaw(tif, buf, cc) == 0)

        {

            memset(buf, 0, (size_t)cc);

            return (0);

        }

    }

    else

    {

        if (OJPEGDecodeScanlines(tif, buf, cc) == 0)

        {

            memset(buf, 0, (size_t)cc);

            return (0);

        }

    }

    return (1);

}

static int OJPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc)

{

    static const char module[] = "OJPEGDecodeRaw";

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint8_t *m;

    tmsize_t n;

    uint8_t *oy;

    uint8_t *ocb;

    uint8_t *ocr;

    uint8_t *p;

    uint32_t q;

    uint8_t *r;

    uint8_t sx, sy;

    if (cc % sp->bytes_per_line != 0)

    {

        TIFFErrorExtR(tif, module, "Fractional scanline not read");

        return (0);

    }

    assert(cc > 0);

    m = buf;

    n = cc;

    do

    {

        if (sp->subsampling_convert_state == 0)

        {

            if (jpeg_read_raw_data_encap(

                    sp, &(sp->libjpeg_jpeg_decompress_struct),

                    sp->subsampling_convert_ycbcrimage,

                    (uint32_t)sp->subsampling_ver * 8) == 0)

            {

                sp->error_in_raw_data_decoding = 1;

                return (0);

            }

        }

        oy = sp->subsampling_convert_ybuf +

             sp->subsampling_convert_state * sp->subsampling_ver *

                 sp->subsampling_convert_ylinelen;

        ocb = sp->subsampling_convert_cbbuf +

              sp->subsampling_convert_state * sp->subsampling_convert_clinelen;

        ocr = sp->subsampling_convert_crbuf +

              sp->subsampling_convert_state * sp->subsampling_convert_clinelen;

        p = m;

        for (q = 0; q < sp->subsampling_convert_clinelenout; q++)

        {

            r = oy;

            for (sy = 0; sy < sp->subsampling_ver; sy++)

            {

                for (sx = 0; sx < sp->subsampling_hor; sx++)

                    *p++ = *r++;

                r += sp->subsampling_convert_ylinelen - sp->subsampling_hor;

            }

            oy += sp->subsampling_hor;

            *p++ = *ocb++;

            *p++ = *ocr++;

        }

        sp->subsampling_convert_state++;

        if (sp->subsampling_convert_state == sp->subsampling_convert_clines)

            sp->subsampling_convert_state = 0;

        m += sp->bytes_per_line;

        n -= sp->bytes_per_line;

    } while (n > 0);

    return (1);

}

static int OJPEGDecodeScanlines(TIFF *tif, uint8_t *buf, tmsize_t cc)

{

    static const char module[] = "OJPEGDecodeScanlines";

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    uint8_t *m;

    tmsize_t n;

    if (cc % sp->bytes_per_line != 0)

    {

        TIFFErrorExtR(tif, module, "Fractional scanline not read");

        return (0);

    }

    assert(cc > 0);

    m = buf;

    n = cc;

    do

    {

        if (jpeg_read_scanlines_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),

                                      &m, 1) == 0)

            return (0);

        m += sp->bytes_per_line;

        n -= sp->bytes_per_line;

    } while (n > 0);

    return (1);

}

static void OJPEGPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc)

{

    OJPEGState *sp = (OJPEGState *)tif->tif_data;

    (void)buf;

    (void)cc;

    /* This function somehow incorrectly assumes that a whole strile was read,

     */

    /* which is not true when TIFFReadScanline() is called, */

    /* and may thus incorrectly consider it has read the whole image, causing */

    /* OJPEGLibjpegSessionAbort() to be called prematurely. */

    /* So this logic should be fixed to take into account cc, or disable */

    /* the scan line reading interface. */

    /* Triggered by https://gitlab.com/libtiff/libtiff/-/issues/337 */

    sp->write_curstrile++;

    if (sp->write_curstrile % tif->tif_dir.td_stripsperimage == 0)

    {

        assert(sp->libjpeg_session_active != 0);

        OJPEGLibjpegSessionAbort(tif);

        sp->writeheader_done = 0;

    }

}

static int OJPEGSetupEncode(TIFF *tif)

{

    static const char module[] = "OJPEGSetupEncode";

    TIFFErrorExtR(

        tif, module,

        "OJPEG encoding not supported; use new-style JPEG compression instead");

    return (0);

}

static int OJPEGPreEncode(TIFF *tif, uint16_t s)

{

    static const char module[] = "OJPEGPreEncode";

    (void)s;

    TIFFErrorExtR(

        tif, module,

        "OJPEG encoding not supported; use new-style JPEG compression instead");

    return (0);